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/sys/contrib/openzfs/.github/workflows/checkstyle.yaml b/sys/contrib/openzfs/.github/workflows/checkstyle.yaml
	index 14a921099e30..553d5df39796 100644
	--- a/sys/contrib/openzfs/.github/workflows/checkstyle.yaml
	+++ b/sys/contrib/openzfs/.github/workflows/checkstyle.yaml
	@@ -1,50 +1,50 @@
	name: checkstyle

	on:
	push:
	pull_request:

	jobs:
	checkstyle:
	- runs-on: ubuntu-18.04
	+ runs-on: ubuntu-20.04
	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 gawk alien fakeroot linux-headers-$(uname -r)
	sudo apt-get install --yes -qq zlib1g-dev uuid-dev libattr1-dev libblkid-dev libselinux-dev libudev-dev libssl-dev python-dev python-setuptools python-cffi python3 python3-dev python3-setuptools python3-cffi
	# packages for tests
	sudo apt-get install --yes -qq parted lsscsi ksh attr acl nfs-kernel-server fio
	sudo apt-get install --yes -qq mandoc cppcheck pax-utils devscripts
	sudo -E pip --quiet install flake8
	- name: Prepare
	run: \|
	sh ./autogen.sh
	./configure
	make -j$(nproc)
	- name: Checkstyle
	run: \|
	make checkstyle
	- name: Lint
	run: \|
	make lint
	- name: CheckABI
	id: CheckABI
	run: \|
	sudo docker run -v $(pwd):/source ghcr.io/openzfs/libabigail make checkabi
	- name: StoreABI
	if: failure() && steps.CheckABI.outcome == 'failure'
	run: \|
	sudo docker run -v $(pwd):/source ghcr.io/openzfs/libabigail make storeabi
	- name: Prepare artifacts
	if: failure() && steps.CheckABI.outcome == 'failure'
	run: \|
	find -name *.abi \| tar -cf abi_files.tar -T -
	- uses: actions/upload-artifact@v2
	if: failure() && steps.CheckABI.outcome == 'failure'
	with:
	name: New ABI files (use only if you're sure about interface changes)
	path: abi_files.tar
	diff --git a/sys/contrib/openzfs/.github/workflows/zfs-tests-functional.yml b/sys/contrib/openzfs/.github/workflows/zfs-tests-functional.yml
	index 79973123fd41..cad763287ea9 100644
	--- a/sys/contrib/openzfs/.github/workflows/zfs-tests-functional.yml
	+++ b/sys/contrib/openzfs/.github/workflows/zfs-tests-functional.yml
	@@ -1,70 +1,81 @@
	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
	+ python3 python3-dev python3-setuptools python3-cffi python3-packaging
	- 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 for cloud-init bug
	+ # see https://github.com/openzfs/zfs/issues/12644
	+ FILE=/lib/udev/rules.d/10-cloud-init-hook-hotplug.rules
	+ if [ -r "${FILE}" ]; then
	+ HASH=$(md5sum "${FILE}" \| awk '{ print $1 }')
	+ if [ "${HASH}" = "121ff0ef1936cd2ef65aec0458a35772" ]; then
	+ # Just shove a zd* exclusion right above the hotplug hook...
	+ sudo sed -i -e s/'LABEL="cloudinit_hook"'/'KERNEL=="zd*", GOTO="cloudinit_end"\n&'/ "${FILE}"
	+ sudo udevadm control --reload-rules
	+ fi
	+ fi
	# 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
	+ /usr/share/zfs/zfs-tests.sh -vR -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
	+ for f in $(find /var/tmp/test_results -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 df089c81f4ce..78187212bb26 100644
	--- a/sys/contrib/openzfs/.github/workflows/zfs-tests-sanity.yml
	+++ b/sys/contrib/openzfs/.github/workflows/zfs-tests-sanity.yml
	@@ -1,66 +1,77 @@
	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
	+ python3 python3-dev python3-setuptools python3-cffi python3-packaging
	- 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 for cloud-init bug
	+ # see https://github.com/openzfs/zfs/issues/12644
	+ FILE=/lib/udev/rules.d/10-cloud-init-hook-hotplug.rules
	+ if [ -r "${FILE}" ]; then
	+ HASH=$(md5sum "${FILE}" \| awk '{ print $1 }')
	+ if [ "${HASH}" = "121ff0ef1936cd2ef65aec0458a35772" ]; then
	+ # Just shove a zd* exclusion right above the hotplug hook...
	+ sudo sed -i -e s/'LABEL="cloudinit_hook"'/'KERNEL=="zd*", GOTO="cloudinit_end"\n&'/ "${FILE}"
	+ sudo udevadm control --reload-rules
	+ fi
	+ fi
	# 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
	+ /usr/share/zfs/zfs-tests.sh -vR -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
	+ for f in $(find /var/tmp/test_results -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/.github/workflows/zloop.yml b/sys/contrib/openzfs/.github/workflows/zloop.yml
	index 22c02b76e395..cf81ad4bcafc 100644
	--- a/sys/contrib/openzfs/.github/workflows/zloop.yml
	+++ b/sys/contrib/openzfs/.github/workflows/zloop.yml
	@@ -1,67 +1,67 @@
	name: zloop

	on:
	push:
	pull_request:

	jobs:
	tests:
	runs-on: ubuntu-latest
	env:
	TEST_DIR: /var/tmp/zloop
	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 \
	git alien fakeroot \
	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 \
	- python-dev python-setuptools python-cffi \
	- python3 python3-dev python3-setuptools python3-cffi
	+ python-dev python-setuptools python-cffi python-packaging \
	+ python3 python3-dev python3-setuptools python3-cffi python3-packaging
	- 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
	- name: Tests
	run: \|
	sudo mkdir -p $TEST_DIR
	# run for 20 minutes to have a total runner time of 30 minutes
	sudo /usr/share/zfs/zloop.sh -t 1200 -l -m1 -- -T 120 -P 60
	- name: Prepare artifacts
	if: failure()
	run: \|
	sudo chmod +r -R $TEST_DIR/
	- uses: actions/upload-artifact@v2
	if: failure()
	with:
	name: Logs
	path: \|
	/var/tmp/zloop/*/
	!/var/tmp/zloop/*/vdev/
	if-no-files-found: ignore
	- uses: actions/upload-artifact@v2
	if: failure()
	with:
	name: Pool files
	path: \|
	/var/tmp/zloop/*/vdev/
	if-no-files-found: ignore
	diff --git a/sys/contrib/openzfs/META b/sys/contrib/openzfs/META
	index 51218270a4ad..10130517955a 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.1
	+Version: 2.1.2
	Release: 1
	Release-Tags: relext
	License: CDDL
	Author: OpenZFS
	-Linux-Maximum: 5.14
	+Linux-Maximum: 5.15
	Linux-Minimum: 3.10
	diff --git a/sys/contrib/openzfs/Makefile.am b/sys/contrib/openzfs/Makefile.am
	index 060729642533..34fe16ce4118 100644
	--- a/sys/contrib/openzfs/Makefile.am
	+++ b/sys/contrib/openzfs/Makefile.am
	@@ -1,235 +1,236 @@
	include $(top_srcdir)/config/Shellcheck.am

	ACLOCAL_AMFLAGS = -I config

	SUBDIRS = include
	if BUILD_LINUX
	SUBDIRS += rpm
	endif

	if CONFIG_USER
	SUBDIRS += man scripts lib tests cmd etc 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 += 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

	SHELLCHECKDIRS = cmd contrib etc scripts tests
	SHELLCHECKSCRIPTS = autogen.sh

	PHONY += checkabi storeabi

	checklibabiversion:
	libabiversion=`abidw -v \| $(SED) 's/[^0-9]//g'`; \
	- if test $$libabiversion -lt "180"; then \
	+ if test $$libabiversion -lt "200"; then \
	/bin/echo -e "\n" \
	- "*** Please use libabigail 1.8.0 version or newer;\n" \
	- "*** otherwise results are not consistent!\n"; \
	+ "*** Please use libabigail 2.0.0 version or newer;\n" \
	+ "*** otherwise results are not consistent!\n" \
	+ "(or see https://github.com/openzfs/libabigail-docker )\n"; \
	exit 1; \
	fi;

	checkabi: checklibabiversion lib
	$(MAKE) -C lib checkabi

	storeabi: checklibabiversion lib
	$(MAKE) -C lib storeabi

	PHONY += mancheck
	mancheck:
	${top_srcdir}/scripts/mancheck.sh ${top_srcdir}/man ${top_srcdir}/tests/test-runner/man

	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/cmd/mount_zfs/mount_zfs.c b/sys/contrib/openzfs/cmd/mount_zfs/mount_zfs.c
	index b9be69d1fb02..de3833698a2b 100644
	--- a/sys/contrib/openzfs/cmd/mount_zfs/mount_zfs.c
	+++ b/sys/contrib/openzfs/cmd/mount_zfs/mount_zfs.c
	@@ -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) 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 '?':
	if (optopt)
	(void) fprintf(stderr,
	gettext("Invalid option '%c'\n"), optopt);
	(void) fprintf(stderr, gettext("Usage: mount.zfs "
	"[-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 */
	+ fallthrough;
	#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 cad59c93f078..8cc4399a5668 100755
	--- a/sys/contrib/openzfs/cmd/vdev_id/vdev_id
	+++ b/sys/contrib/openzfs/cmd/vdev_id/vdev_id
	@@ -1,789 +1,789 @@
	#!/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 1
	# exit with error to avoid processing usage message by a udev rule
	}

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

	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 \
	{ 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}')
	+ PHY=$(ls -vd "$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)
	+ NAME=$(awk "/channel/{if (\$1 == \"channel\" && \$2 == \"$PCI_ID\" && \
	+ \$3 == \"$PORT_ID\") {print \$4\$3}}" $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 1
	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 e964e3ba8acf..9de41cef2003 100644
	--- a/sys/contrib/openzfs/cmd/zdb/zdb.c
	+++ b/sys/contrib/openzfs/cmd/zdb/zdb.c
	@@ -1,8773 +1,8773 @@
	/*
	* 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 {
	/* 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);

	typedef struct sublivelist_verify_block_refcnt {
	/* block pointer entry in livelist being verified */
	blkptr_t svbr_blk;

	/*
	* Refcount gets incremented to 1 when we encounter the first
	* FREE entry for the svfbr block pointer and a node for it
	* is created in our ZDB verification/tracking metadata.
	*
	* As we encounter more FREE entries we increment this counter
	* and similarly decrement it whenever we find the respective
	* ALLOC entries for this block.
	*
	* When the refcount gets to 0 it means that all the FREE and
	* ALLOC entries of this block have paired up and we no longer
	* need to track it in our verification logic (e.g. the node
	* containing this struct in our verification data structure
	* should be freed).
	*
	* [refer to sublivelist_verify_blkptr() for the actual code]
	*/
	uint32_t svbr_refcnt;
	} sublivelist_verify_block_refcnt_t;

	static int
	sublivelist_block_refcnt_compare(const void larg, const void rarg)
	{
	const sublivelist_verify_block_refcnt_t *l = larg;
	const sublivelist_verify_block_refcnt_t *r = rarg;
	return (livelist_compare(&l->svbr_blk, &r->svbr_blk));
	}

	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;
	sublivelist_verify_block_refcnt_t current = {
	.svbr_blk = *bp,

	/*
	* Start with 1 in case this is the first free entry.
	* This field is not used for our B-Tree comparisons
	* anyway.
	*/
	.svbr_refcnt = 1,
	};

	zfs_btree_index_t where;
	sublivelist_verify_block_refcnt_t *pair =
	zfs_btree_find(&sv->sv_pair, &current, &where);
	if (free) {
	if (pair == NULL) {
	/* first free entry for this block pointer */
	zfs_btree_add(&sv->sv_pair, &current);
	} else {
	pair->svbr_refcnt++;
	}
	} else {
	if (pair == NULL) {
	/* block that is currently marked as allocated */
	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);
	}
	}
	} else {
	/* alloc matches a free entry */
	pair->svbr_refcnt--;
	if (pair->svbr_refcnt == 0) {
	/* all allocs and frees have been matched */
	zfs_btree_remove_idx(&sv->sv_pair, &where);
	}
	}
	}

	return (0);
	}

	static int
	sublivelist_verify_func(void args, dsl_deadlist_entry_t dle)
	{
	int err;
	struct sublivelist_verify *sv = args;

	zfs_btree_create(&sv->sv_pair, sublivelist_block_refcnt_compare,
	sizeof (sublivelist_verify_block_refcnt_t));

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

	sublivelist_verify_block_refcnt_t *e;
	zfs_btree_index_t *cookie = NULL;
	while ((e = zfs_btree_destroy_nodes(&sv->sv_pair, &cookie)) != NULL) {
	char blkbuf[BP_SPRINTF_LEN];
	snprintf_blkptr_compact(blkbuf, sizeof (blkbuf),
	&e->svbr_blk, B_TRUE);
	(void) printf("\tERROR: %d unmatched FREE(s): %s\n",
	e->svbr_refcnt, 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 (**)
	* - record leftover ALLOCs together with their TXG [see Cross Check]
	*
	* (**) Note: Double ALLOCs are valid in datasets that have dedup
	* enabled. Similarly double FREEs are allowed as well but
	* only if they pair up with a corresponding ALLOC entry once
	* we our done with our sublivelist iteration.
	*
	* [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, zfs_get_hdrversion(&zstd_hdr),
	zfs_get_hdrlevel(&zstd_hdr));
	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, zfs_get_hdrversion(&zstd_hdr),
	zfs_get_hdrlevel(&zstd_hdr));

	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;
	+ int difference = 0;

	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/
	+ 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 __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];
	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/zed.d/statechange-led.sh b/sys/contrib/openzfs/cmd/zed/zed.d/statechange-led.sh
	index 0f9da3204317..26e6064fa94a 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,240 @@
	#!/bin/sh
	#
	# Turn off/on vdevs' enclosure fault LEDs when their pool's state changes.
	#
	# 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
	# events and some vdev_* events.
	#
	# 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
	# 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
	+if [ ! -d /sys/class/enclosure ] && [ ! -d /sys/bus/pci/slots ] ; then
	+ # No JBOD enclosure or NVMe slots
	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 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.
	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
	}

	+# Fault LEDs for JBODs and NVMe drives are handled a little differently.
	+#
	+# On JBODs the fault LED is called 'fault' and on a path like this:
	+#
	+# /sys/class/enclosure/0:0:1:0/SLOT 10/fault
	+#
	+# On NVMe it's called 'attention' and on a path like this:
	+#
	+# /sys/bus/pci/slot/0/attention
	+#
	+# This function returns the full path to the fault LED file for a given
	+# enclosure/slot directory.
	+#
	+path_to_led()
	+{
	+ dir=$1
	+ if [ -f "$dir/fault" ] ; then
	+ echo "$dir/fault"
	+ elif [ -f "$dir/attention" ] ; then
	+ echo "$dir/attention"
	+ fi
	+}
	+
	state_to_val()
	{
	state="$1"
	case "$state" in
	FAULTED\|DEGRADED\|UNAVAIL)
	echo 1
	;;
	ONLINE)
	echo 0
	;;
	esac
	}

	+#
	+# Given a nvme name like 'nvme0n1', pass back its slot directory
	+# like "/sys/bus/pci/slots/0"
	+#
	+nvme_dev_to_slot()
	+{
	+ dev="$1"
	+
	+ # Get the address "0000:01:00.0"
	+ address=$(cat "/sys/class/block/$dev/device/address")
	+
	+ # For each /sys/bus/pci/slots subdir that is an actual number
	+ # (rather than weird directories like "1-3/").
	+ # shellcheck disable=SC2010
	+ for i in $(ls /sys/bus/pci/slots/ \| grep -E "^[0-9]+$") ; do
	+ this_address=$(cat "/sys/bus/pci/slots/$i/address")
	+
	+ # The format of address is a little different between
	+ # /sys/class/block/$dev/device/address and
	+ # /sys/bus/pci/slots/
	+ #
	+ # address= "0000:01:00.0"
	+ # this_address = "0000:01:00"
	+ #
	+ if echo "$address" \| grep -Eq ^"$this_address" ; then
	+ echo "/sys/bus/pci/slots/$i"
	+ break
	+ fi
	+ done
	+}
	+
	+
	# process_pool (pool)
	#
	# Iterate through a pool and set the vdevs' enclosure slot LEDs to
	# those vdevs' state.
	#
	# Arguments
	# pool: Pool name.
	#
	# Return
	# 0 on success, 3 on missing sysfs path
	#
	process_pool()
	{
	pool="$1"

	# 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
	# 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"*)
	+ if [ ! -d "$vdev_enc_sysfs_path" ] ; then
	+ # This is not a JBOD disk, but it could be a PCI NVMe drive
	+ vdev_enc_sysfs_path=$(nvme_dev_to_slot "$dev")
	+ fi
	+
	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
	+ led_path=$(path_to_led "$vdev_enc_sysfs_path")
	+ if [ ! -e "$led_path" ] ; then
	rc=3
	- zed_log_msg "vdev $vdev '$file/fault' doesn't exist"
	+ zed_log_msg "vdev $vdev '$led_path' doesn't exist"
	continue
	fi

	val=$(state_to_val "$state")

	if [ "$current_val" = "$val" ] ; then
	# LED is already set correctly
	continue
	fi

	- if ! check_and_set_led "$vdev_enc_sysfs_path/fault" "$val"; then
	+ if ! check_and_set_led "$led_path" "$val"; then
	rc=3
	fi
	done
	exit "$rc"; )
	}

	if [ -n "$ZEVENT_VDEV_ENC_SYSFS_PATH" ] && [ -n "$ZEVENT_VDEV_STATE_STR" ] ; then
	# 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"
	+ ledpath=$(path_to_led "$ZEVENT_VDEV_ENC_SYSFS_PATH")
	+ check_and_set_led "$ledpath" "$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/zed.rc b/sys/contrib/openzfs/cmd/zed/zed.d/zed.rc
	index df560f921e60..1c278b2ef96e 100644
	--- a/sys/contrib/openzfs/cmd/zed/zed.d/zed.rc
	+++ b/sys/contrib/openzfs/cmd/zed/zed.d/zed.rc
	@@ -1,127 +1,127 @@
	##
	# zed.rc
	#
	# This file should be owned by root and permissioned 0600.
	##

	##
	# Absolute path to the debug output file.
	#
	#ZED_DEBUG_LOG="/tmp/zed.debug.log"

	##
	# Email address of the zpool administrator for receipt of notifications;
	# multiple addresses can be specified if they are delimited by whitespace.
	# Email will only be sent if ZED_EMAIL_ADDR is defined.
	# Disabled by default; uncomment to enable.
	#
	#ZED_EMAIL_ADDR="root"

	##
	# Name or path of executable responsible for sending notifications via email;
	# the mail program must be capable of reading a message body from stdin.
	# Email will only be sent if ZED_EMAIL_ADDR is defined.
	#
	#ZED_EMAIL_PROG="mail"

	##
	# Command-line options for ZED_EMAIL_PROG.
	# The string @ADDRESS@ will be replaced with the recipient email address(es).
	# The string @SUBJECT@ will be replaced with the notification subject;
	# this should be protected with quotes to prevent word-splitting.
	# Email will only be sent if ZED_EMAIL_ADDR is defined.
	#
	#ZED_EMAIL_OPTS="-s '@SUBJECT@' @ADDRESS@"

	##
	# Default directory for zed lock files.
	#
	#ZED_LOCKDIR="/var/lock"

	##
	# Minimum number of seconds between notifications for a similar event.
	#
	#ZED_NOTIFY_INTERVAL_SECS=3600

	##
	# Notification verbosity.
	# If set to 0, suppress notification if the pool is healthy.
	# If set to 1, send notification regardless of pool health.
	#
	#ZED_NOTIFY_VERBOSE=0

	##
	# Send notifications for 'ereport.fs.zfs.data' events.
	# Disabled by default, any non-empty value will enable the feature.
	#
	#ZED_NOTIFY_DATA=

	##
	# Pushbullet access token.
	# This grants full access to your account -- protect it accordingly!
	# <https://www.pushbullet.com/get-started>
	# <https://www.pushbullet.com/account>
	# Disabled by default; uncomment to enable.
	#
	#ZED_PUSHBULLET_ACCESS_TOKEN=""

	##
	# Pushbullet channel tag for push notification feeds that can be subscribed to.
	# <https://www.pushbullet.com/my-channel>
	# If not defined, push notifications will instead be sent to all devices
	# associated with the account specified by the access token.
	# Disabled by default; uncomment to enable.
	#
	#ZED_PUSHBULLET_CHANNEL_TAG=""

	##
	# Slack Webhook URL.
	# This allows posting to the given channel and includes an access token.
	# <https://api.slack.com/incoming-webhooks>
	# Disabled by default; uncomment to enable.
	#
	#ZED_SLACK_WEBHOOK_URL=""

	##
	# Default directory for zed state files.
	#
	#ZED_RUNDIR="/var/run"

	##
	# Turn on/off enclosure LEDs when drives get DEGRADED/FAULTED. This works for
	-# device mapper and multipath devices as well. Your enclosure must be
	-# supported by the Linux SES driver for this to work.
	+# device mapper and multipath devices as well. This works with JBOD enclosures
	+# and NVMe PCI drives (assuming they're supported by Linux in sysfs).
	#
	ZED_USE_ENCLOSURE_LEDS=1

	##
	# Run a scrub after every resilver
	# Disabled by default, 1 to enable and 0 to disable.
	#ZED_SCRUB_AFTER_RESILVER=0

	##
	# The syslog priority (e.g., specified as a "facility.level" pair).
	#
	#ZED_SYSLOG_PRIORITY="daemon.notice"

	##
	# The syslog tag for marking zed events.
	#
	#ZED_SYSLOG_TAG="zed"

	##
	# Which set of event subclasses to log
	# By default, events from all subclasses are logged.
	# If ZED_SYSLOG_SUBCLASS_INCLUDE is set, only subclasses
	# matching the pattern are logged. Use the pipe symbol (\|)
	# or shell wildcards (*, ?) to match multiple subclasses.
	# Otherwise, if ZED_SYSLOG_SUBCLASS_EXCLUDE is set, the
	# matching subclasses are excluded from logging.
	#ZED_SYSLOG_SUBCLASS_INCLUDE="checksum\|scrub_\|vdev."
	ZED_SYSLOG_SUBCLASS_EXCLUDE="history_event"

	##
	# Use GUIDs instead of names when logging pool and vdevs
	# Disabled by default, 1 to enable and 0 to disable.
	#ZED_SYSLOG_DISPLAY_GUIDS=1

	diff --git a/sys/contrib/openzfs/cmd/zfs/zfs_main.c b/sys/contrib/openzfs/cmd/zfs/zfs_main.c
	index 7806d86398a9..d0bb73a72513 100644
	--- a/sys/contrib/openzfs/cmd/zfs/zfs_main.c
	+++ b/sys/contrib/openzfs/cmd/zfs/zfs_main.c
	@@ -1,8802 +1,8803 @@
	/*
	* 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 [-DnvPLecw] [-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;
	}

	/* This function checks if the passed fd refers to /dev/null or /dev/zero */
	#ifdef __linux__
	static boolean_t
	is_dev_nullzero(int fd)
	{
	struct stat st;
	fstat(fd, &st);
	return (major(st.st_rdev) == 1 && (minor(st.st_rdev) == 3 /* null */ \|\|
	minor(st.st_rdev) == 5 /* zero */));
	}
	#endif

	static void
	note_dev_error(int err, int fd)
	{
	#ifdef __linux__
	if (err == EINVAL && is_dev_nullzero(fd)) {
	(void) fprintf(stderr,
	gettext("Error: Writing directly to /dev/{null,zero} files"
	" on certain kernels is not currently implemented.\n"
	"(As a workaround, "
	"try \"zfs send [...] \| cat > /dev/null\")\n"));
	}
	#endif
	}

	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: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);
	if (err != 0)
	note_dev_error(errno, STDOUT_FILENO);
	zfs_close(zhp);
	return (err != 0);
	} else if (resume_token != NULL) {
	err = zfs_send_resume(g_zfs, &flags, STDOUT_FILENO,
	resume_token);
	if (err != 0)
	note_dev_error(errno, STDOUT_FILENO);
	return (err);
	}

	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);
	if (err != 0)
	note_dev_error(errno, STDOUT_FILENO);
	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);
	note_dev_error(errno, STDOUT_FILENO);

	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;
	+ break;
	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/zpool/Makefile.am b/sys/contrib/openzfs/cmd/zpool/Makefile.am
	index aad45d4f7497..fa494c030e1c 100644
	--- a/sys/contrib/openzfs/cmd/zpool/Makefile.am
	+++ b/sys/contrib/openzfs/cmd/zpool/Makefile.am
	@@ -1,188 +1,189 @@
	include $(top_srcdir)/config/Rules.am
	include $(top_srcdir)/config/Shellcheck.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
	+ $(abs_top_builddir)/lib/libuutil/libuutil.la \
	+ $(abs_top_builddir)/lib/libzutil/libzutil.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/zpool.d/ses b/sys/contrib/openzfs/cmd/zpool/zpool.d/ses
	index f6b7520dfb6c..b1836d676528 100755
	--- a/sys/contrib/openzfs/cmd/zpool/zpool.d/ses
	+++ b/sys/contrib/openzfs/cmd/zpool/zpool.d/ses
	@@ -1,52 +1,58 @@
	#!/bin/sh
	#
	# Print SCSI Enclosure Services (SES) info. The output is dependent on the name
	# of the script/symlink used to call it.
	#
	helpstr="
	enc: Show disk enclosure w:x:y:z value.
	slot: Show disk slot number as reported by the enclosure.
	encdev: Show /dev/sg* device associated with the enclosure disk slot.
	fault_led: Show value of the disk enclosure slot fault LED.
	locate_led: Show value of the disk enclosure slot locate LED.
	ses: Show disk's enc, enc device, slot, and fault/locate LED values."

	script=$(basename "$0")
	if [ "$1" = "-h" ] ; then
	echo "$helpstr" \| grep "$script:" \| tr -s '\t' \| cut -f 2-
	exit
	fi

	if [ "$script" = "ses" ] ; then
	scripts='enc encdev slot fault_led locate_led'
	else
	scripts="$script"
	fi

	for i in $scripts ; do
	if [ -z "$VDEV_ENC_SYSFS_PATH" ] ; then
	echo "$i="
	continue
	fi

	val=""
	case $i in
	enc)
	val=$(ls "$VDEV_ENC_SYSFS_PATH/../../" 2>/dev/null)
	;;
	slot)
	val=$(cat "$VDEV_ENC_SYSFS_PATH/slot" 2>/dev/null)
	;;
	encdev)
	val=$(ls "$VDEV_ENC_SYSFS_PATH/../device/scsi_generic" 2>/dev/null)
	;;
	fault_led)
	- val=$(cat "$VDEV_ENC_SYSFS_PATH/fault" 2>/dev/null)
	+ # JBODs fault LED is called 'fault', NVMe fault LED is called
	+ # 'attention'.
	+ if [ -f "$VDEV_ENC_SYSFS_PATH/fault" ] ; then
	+ val=$(cat "$VDEV_ENC_SYSFS_PATH/fault" 2>/dev/null)
	+ elif [ -f "$VDEV_ENC_SYSFS_PATH/attention" ] ; then
	+ val=$(cat "$VDEV_ENC_SYSFS_PATH/attention" 2>/dev/null)
	+ fi
	;;
	locate_led)
	val=$(cat "$VDEV_ENC_SYSFS_PATH/locate" 2>/dev/null)
	;;
	esac
	echo "$i=$val"
	done

	diff --git a/sys/contrib/openzfs/cmd/zpool/zpool_iter.c b/sys/contrib/openzfs/cmd/zpool/zpool_iter.c
	index 3d7a0cfc35e6..abfa2b7f6b90 100644
	--- a/sys/contrib/openzfs/cmd/zpool/zpool_iter.c
	+++ b/sys/contrib/openzfs/cmd/zpool/zpool_iter.c
	@@ -1,768 +1,724 @@
	/*
	* 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));
	+ return (for_each_vdev_cb((void *) 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) {
	env[1] = NULL;
	goto out;
	}

	rc = asprintf(&env[2], "VDEV_UPATH=%s",
	data->upath ? data->upath : "");
	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) {
	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++)
	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)
	+for_each_vdev_run_cb(void zhp_data, 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;
	+ zpool_handle_t *zhp = zhp_data;

	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 f95aece9561d..9cf0163ab327 100644
	--- a/sys/contrib/openzfs/cmd/zpool/zpool_main.c
	+++ b/sys/contrib/openzfs/cmd/zpool/zpool_main.c
	@@ -1,10783 +1,10784 @@
	/*
	* 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(7).\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 *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);
	}

	/*
	* 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, 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 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);
	}

	/*
	* Return 1 if a vdev is active (being used in a pool)
	* Return 0 if a vdev is inactive (offlined or faulted, or not in active pool)
	*
	* This is useful for checking if a disk in an active pool is offlined or
	* faulted.
	*/
	static int
	vdev_is_active(char *vdev_path)
	{
	int fd;
	fd = open(vdev_path, O_EXCL);
	if (fd < 0) {
	return (1); /* cant open O_EXCL - disk is active */
	}

	close(fd);
	return (0); /* disk is inactive in the pool */
	}

	/*
	* 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:
	/*
	* We allow the user to call 'zpool offline -f'
	* on an offlined disk in an active pool. We can check if
	* the disk is online by calling vdev_is_active().
	*/
	if (force && !vdev_is_active(vdev))
	break;

	(void) fprintf(stderr, gettext(
	"%s is a member (%s) of pool \"%s\""),
	vdev, zpool_pool_state_to_name(state), name);

	if (force) {
	(void) fprintf(stderr, gettext(
	". Offline the disk first to clear its label."));
	}
	printf("\n");
	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 "
	"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,
	argc >= 1 ? argv[0] : NULL,
	argc >= 2 ? argv[1] : NULL,
	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,
	argc >= 1 ? argv[0] : NULL,
	argc >= 2 ? argv[1] : NULL,
	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"));
	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"));
	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)
	+is_vdev_cb(void zhp_data, nvlist_t nv, void *cb_data)
	{
	iostat_cbdata_t *cb = cb_data;
	char *name = NULL;
	int ret = 0;
	+ zpool_handle_t *zhp = zhp_data;

	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;
	(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_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(7) 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 modified_pool = 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);
	modified_pool = 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;
	modified_pool = B_TRUE;
	}
	}

	if (modified_pool) {
	(void) printf("\n");
	(void) after_zpool_upgrade(zhp);
	}

	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"
	"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(7) for "
	"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 modified_pool = 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) {
	modified_pool = 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) {
	modified_pool = 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 (modified_pool) {
	(void) printf("\n");
	(void) after_zpool_upgrade(zhp);
	}

	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 report[1024];

	zpool_compat_status_t ret;

	ret = zpool_load_compat(compat, list, report, 1024);
	switch (ret) {

	case ZPOOL_COMPATIBILITY_OK:
	break;

	case ZPOOL_COMPATIBILITY_NOFILES:
	case ZPOOL_COMPATIBILITY_BADFILE:
	case ZPOOL_COMPATIBILITY_BADTOKEN:
	(void) fprintf(stderr, "Error: %s\n", report);
	break;

	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_util.h b/sys/contrib/openzfs/cmd/zpool/zpool_util.h
	index 493f8cb98043..da75866f5145 100644
	--- a/sys/contrib/openzfs/cmd/zpool/zpool_util.h
	+++ b/sys/contrib/openzfs/cmd/zpool/zpool_util.h
	@@ -1,138 +1,138 @@
	/*
	* 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.
	*/

	#ifndef ZPOOL_UTIL_H
	#define ZPOOL_UTIL_H

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

	#ifdef __cplusplus
	extern "C" {
	#endif

	/* Path to scripts you can run with "zpool status/iostat -c" */
	#define ZPOOL_SCRIPTS_DIR SYSCONFDIR"/zfs/zpool.d"

	/*
	* Basic utility functions
	*/
	void *safe_malloc(size_t);
	void zpool_no_memory(void);
	uint_t num_logs(nvlist_t *nv);
	uint64_t array64_max(uint64_t array[], unsigned int len);
	int highbit64(uint64_t i);
	int lowbit64(uint64_t i);

	/*
	* Misc utility functions
	*/
	char *zpool_get_cmd_search_path(void);

	/*
	* Virtual device functions
	*/

	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 split_mirror_vdev(zpool_handle_t zhp, char *newname,
	nvlist_t props, splitflags_t flags, int argc, char *argv);

	/*
	* Pool list functions
	*/
	int for_each_pool(int, char , boolean_t unavail, zprop_list_t ,
	boolean_t, zpool_iter_f, void *);

	/* Vdev list functions */
	-typedef int (pool_vdev_iter_f)(zpool_handle_t , nvlist_t , void );
	int for_each_vdev(zpool_handle_t zhp, pool_vdev_iter_f func, void data);

	typedef struct zpool_list zpool_list_t;

	zpool_list_t pool_list_get(int, char , zprop_list_t , boolean_t, int );
	void pool_list_update(zpool_list_t *);
	int pool_list_iter(zpool_list_t , int unavail, zpool_iter_f, void );
	void pool_list_free(zpool_list_t *);
	int pool_list_count(zpool_list_t *);
	void pool_list_remove(zpool_list_t , zpool_handle_t );

	extern libzfs_handle_t *g_zfs;


	typedef struct vdev_cmd_data
	{
	char *lines; / Array of lines of output, minus the column name */
	int lines_cnt; /* Number of lines in the array */

	char *cols; / Array of column names */
	int cols_cnt; /* Number of column names */


	char path; / vdev path */
	char upath; / vdev underlying path */
	char pool; / Pool name */
	char cmd; / backpointer to cmd */
	char vdev_enc_sysfs_path; / enclosure sysfs path (if any) */
	} vdev_cmd_data_t;

	typedef struct vdev_cmd_data_list
	{
	char cmd; / Command to run */
	unsigned int count; /* Number of vdev_cmd_data items (vdevs) */

	/* fields used to select only certain vdevs, if requested */
	libzfs_handle_t *g_zfs;
	char **vdev_names;
	int vdev_names_count;
	int cb_name_flags;

	vdev_cmd_data_t data; / Array of vdevs */

	/* List of unique column names and widths */
	char **uniq_cols;
	int uniq_cols_cnt;
	int *uniq_cols_width;

	} vdev_cmd_data_list_t;

	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);

	void free_vdev_cmd_data_list(vdev_cmd_data_list_t *vcdl);

	int check_device(const char *path, boolean_t force,
	boolean_t isspare, boolean_t iswholedisk);
	boolean_t check_sector_size_database(char path, int sector_size);
	void vdev_error(const char *fmt, ...);
	int check_file(const char *file, boolean_t force, boolean_t isspare);
	void after_zpool_upgrade(zpool_handle_t *zhp);

	#ifdef __cplusplus
	}
	#endif

	#endif /* ZPOOL_UTIL_H */
	diff --git a/sys/contrib/openzfs/cmd/zpool_influxdb/zpool_influxdb.c b/sys/contrib/openzfs/cmd/zpool_influxdb/zpool_influxdb.c
	index 35c4770a1c14..d0b6e172ae57 100644
	--- a/sys/contrib/openzfs/cmd/zpool_influxdb/zpool_influxdb.c
	+++ b/sys/contrib/openzfs/cmd/zpool_influxdb/zpool_influxdb.c
	@@ -1,842 +1,843 @@
	/*
	* Gather top-level ZFS pool and resilver/scan statistics and print using
	* influxdb line protocol
	* usage: [options] [pool_name]
	* where options are:
	* --execd, -e run in telegraf execd input plugin mode, [CR] on
	* stdin causes a sample to be printed and wait for
	* the next [CR]
	* --no-histograms, -n don't print histogram data (reduces cardinality
	* if you don't care about histograms)
	* --sum-histogram-buckets, -s sum histogram bucket values
	*
	* To integrate into telegraf use one of:
	* 1. the `inputs.execd` plugin with the `--execd` option
	* 2. the `inputs.exec` plugin to simply run with no options
	*
	* NOTE: libzfs is an unstable interface. YMMV.
	*
	* The design goals of this software include:
	* + be as lightweight as possible
	* + reduce the number of external dependencies as far as possible, hence
	* there is no dependency on a client library for managing the metric
	* collection -- info is printed, KISS
	* + broken pools or kernel bugs can cause this process to hang in an
	* unkillable state. For this reason, it is best to keep the damage limited
	* to a small process like zpool_influxdb rather than a larger collector.
	*
	* Copyright 2018-2020 Richard Elling
	*
	* This software is dual-licensed MIT and CDDL.
	*
	* The MIT License (MIT)
	*
	* 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.
	*
	* 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.
	*
	* 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.
	*
	* See the License for the specific language governing permissions
	* and limitations under the License.
	*
	* CDDL HEADER END
	*/
	#include <string.h>
	#include <getopt.h>
	#include <stdio.h>
	#include <stdint.h>
	#include <inttypes.h>
	#include <libzfs_impl.h>

	#define POOL_MEASUREMENT "zpool_stats"
	#define SCAN_MEASUREMENT "zpool_scan_stats"
	#define VDEV_MEASUREMENT "zpool_vdev_stats"
	#define POOL_LATENCY_MEASUREMENT "zpool_latency"
	#define POOL_QUEUE_MEASUREMENT "zpool_vdev_queue"
	#define MIN_LAT_INDEX 10 /* minimum latency index 10 = 1024ns */
	#define POOL_IO_SIZE_MEASUREMENT "zpool_io_size"
	#define MIN_SIZE_INDEX 9 /* minimum size index 9 = 512 bytes */

	/* global options */
	int execd_mode = 0;
	int no_histograms = 0;
	int sum_histogram_buckets = 0;
	char metric_data_type = 'u';
	uint64_t metric_value_mask = UINT64_MAX;
	uint64_t timestamp = 0;
	int complained_about_sync = 0;
	char *tags = "";

	typedef int (stat_printer_f)(nvlist_t , const char , const char );

	/*
	* influxdb line protocol rules for escaping are important because the
	* zpool name can include characters that need to be escaped
	*
	* caller is responsible for freeing result
	*/
	static char *
	escape_string(char *s)
	{
	char c, d;
	char t = (char )malloc(ZFS_MAX_DATASET_NAME_LEN * 2);
	if (t == NULL) {
	fprintf(stderr, "error: cannot allocate memory\n");
	exit(1);
	}

	for (c = s, d = t; *c != '\0'; c++, d++) {
	switch (*c) {
	case ' ':
	case ',':
	case '=':
	case '\\':
	*d++ = '\\';
	+ fallthrough;
	default:
	d = c;
	}
	}
	*d = '\0';
	return (t);
	}

	/*
	* print key=value where value is a uint64_t
	*/
	static void
	print_kv(char *key, uint64_t value)
	{
	printf("%s=%llu%c", key,
	(u_longlong_t)value & metric_value_mask, metric_data_type);
	}

	/*
	* print_scan_status() prints the details as often seen in the "zpool status"
	* output. However, unlike the zpool command, which is intended for humans,
	* this output is suitable for long-term tracking in influxdb.
	* TODO: update to include issued scan data
	*/
	static int
	print_scan_status(nvlist_t nvroot, const char pool_name)
	{
	uint_t c;
	int64_t elapsed;
	uint64_t examined, pass_exam, paused_time, paused_ts, rate;
	uint64_t remaining_time;
	pool_scan_stat_t *ps = NULL;
	double pct_done;
	char *state[DSS_NUM_STATES] = {
	"none", "scanning", "finished", "canceled"};
	char *func;

	(void) nvlist_lookup_uint64_array(nvroot,
	ZPOOL_CONFIG_SCAN_STATS,
	(uint64_t **)&ps, &c);

	/*
	* ignore if there are no stats
	*/
	if (ps == NULL)
	return (0);

	/*
	* return error if state is bogus
	*/
	if (ps->pss_state >= DSS_NUM_STATES \|\|
	ps->pss_func >= POOL_SCAN_FUNCS) {
	if (complained_about_sync % 1000 == 0) {
	fprintf(stderr, "error: cannot decode scan stats: "
	"ZFS is out of sync with compiled zpool_influxdb");
	complained_about_sync++;
	}
	return (1);
	}

	switch (ps->pss_func) {
	case POOL_SCAN_NONE:
	func = "none_requested";
	break;
	case POOL_SCAN_SCRUB:
	func = "scrub";
	break;
	case POOL_SCAN_RESILVER:
	func = "resilver";
	break;
	#ifdef POOL_SCAN_REBUILD
	case POOL_SCAN_REBUILD:
	func = "rebuild";
	break;
	#endif
	default:
	func = "scan";
	}

	/* overall progress */
	examined = ps->pss_examined ? ps->pss_examined : 1;
	pct_done = 0.0;
	if (ps->pss_to_examine > 0)
	pct_done = 100.0 * examined / ps->pss_to_examine;

	#ifdef EZFS_SCRUB_PAUSED
	paused_ts = ps->pss_pass_scrub_pause;
	paused_time = ps->pss_pass_scrub_spent_paused;
	#else
	paused_ts = 0;
	paused_time = 0;
	#endif

	/* calculations for this pass */
	if (ps->pss_state == DSS_SCANNING) {
	elapsed = (int64_t)time(NULL) - (int64_t)ps->pss_pass_start -
	(int64_t)paused_time;
	elapsed = (elapsed > 0) ? elapsed : 1;
	pass_exam = ps->pss_pass_exam ? ps->pss_pass_exam : 1;
	rate = pass_exam / elapsed;
	rate = (rate > 0) ? rate : 1;
	remaining_time = ps->pss_to_examine - examined / rate;
	} else {
	elapsed =
	(int64_t)ps->pss_end_time - (int64_t)ps->pss_pass_start -
	(int64_t)paused_time;
	elapsed = (elapsed > 0) ? elapsed : 1;
	pass_exam = ps->pss_pass_exam ? ps->pss_pass_exam : 1;
	rate = pass_exam / elapsed;
	remaining_time = 0;
	}
	rate = rate ? rate : 1;

	/* influxdb line protocol format: "tags metrics timestamp" */
	printf("%s%s,function=%s,name=%s,state=%s ",
	SCAN_MEASUREMENT, tags, func, pool_name, state[ps->pss_state]);
	print_kv("end_ts", ps->pss_end_time);
	print_kv(",errors", ps->pss_errors);
	print_kv(",examined", examined);
	print_kv(",issued", ps->pss_issued);
	print_kv(",pass_examined", pass_exam);
	print_kv(",pass_issued", ps->pss_pass_issued);
	print_kv(",paused_ts", paused_ts);
	print_kv(",paused_t", paused_time);
	printf(",pct_done=%.2f", pct_done);
	print_kv(",processed", ps->pss_processed);
	print_kv(",rate", rate);
	print_kv(",remaining_t", remaining_time);
	print_kv(",start_ts", ps->pss_start_time);
	print_kv(",to_examine", ps->pss_to_examine);
	print_kv(",to_process", ps->pss_to_process);
	printf(" %llu\n", (u_longlong_t)timestamp);
	return (0);
	}

	/*
	* get a vdev name that corresponds to the top-level vdev names
	* printed by `zpool status`
	*/
	static char *
	get_vdev_name(nvlist_t nvroot, const char parent_name)
	{
	static char vdev_name[256];
	char *vdev_type = NULL;
	uint64_t vdev_id = 0;

	if (nvlist_lookup_string(nvroot, ZPOOL_CONFIG_TYPE,
	&vdev_type) != 0) {
	vdev_type = "unknown";
	}
	if (nvlist_lookup_uint64(
	nvroot, ZPOOL_CONFIG_ID, &vdev_id) != 0) {
	vdev_id = UINT64_MAX;
	}
	if (parent_name == NULL) {
	(void) snprintf(vdev_name, sizeof (vdev_name), "%s",
	vdev_type);
	} else {
	(void) snprintf(vdev_name, sizeof (vdev_name),
	"%s/%s-%llu",
	parent_name, vdev_type, (u_longlong_t)vdev_id);
	}
	return (vdev_name);
	}

	/*
	* get a string suitable for an influxdb tag that describes this vdev
	*
	* By default only the vdev hierarchical name is shown, separated by '/'
	* If the vdev has an associated path, which is typical of leaf vdevs,
	* then the path is added.
	* It would be nice to have the devid instead of the path, but under
	* Linux we cannot be sure a devid will exist and we'd rather have
	* something than nothing, so we'll use path instead.
	*/
	static char *
	get_vdev_desc(nvlist_t nvroot, const char parent_name)
	{
	static char vdev_desc[2 * MAXPATHLEN];
	char *vdev_type = NULL;
	uint64_t vdev_id = 0;
	char vdev_value[MAXPATHLEN];
	char *vdev_path = NULL;
	char s, t;

	if (nvlist_lookup_string(nvroot, ZPOOL_CONFIG_TYPE, &vdev_type) != 0) {
	vdev_type = "unknown";
	}
	if (nvlist_lookup_uint64(nvroot, ZPOOL_CONFIG_ID, &vdev_id) != 0) {
	vdev_id = UINT64_MAX;
	}
	if (nvlist_lookup_string(
	nvroot, ZPOOL_CONFIG_PATH, &vdev_path) != 0) {
	vdev_path = NULL;
	}

	if (parent_name == NULL) {
	s = escape_string(vdev_type);
	(void) snprintf(vdev_value, sizeof (vdev_value), "vdev=%s", s);
	free(s);
	} else {
	s = escape_string((char *)parent_name);
	t = escape_string(vdev_type);
	(void) snprintf(vdev_value, sizeof (vdev_value),
	"vdev=%s/%s-%llu", s, t, (u_longlong_t)vdev_id);
	free(s);
	free(t);
	}
	if (vdev_path == NULL) {
	(void) snprintf(vdev_desc, sizeof (vdev_desc), "%s",
	vdev_value);
	} else {
	s = escape_string(vdev_path);
	(void) snprintf(vdev_desc, sizeof (vdev_desc), "path=%s,%s",
	s, vdev_value);
	free(s);
	}
	return (vdev_desc);
	}

	/*
	* vdev summary stats are a combination of the data shown by
	* `zpool status` and `zpool list -v`
	*/
	static int
	print_summary_stats(nvlist_t nvroot, const char pool_name,
	const char *parent_name)
	{
	uint_t c;
	vdev_stat_t *vs;
	char *vdev_desc = NULL;
	vdev_desc = get_vdev_desc(nvroot, parent_name);
	if (nvlist_lookup_uint64_array(nvroot, ZPOOL_CONFIG_VDEV_STATS,
	(uint64_t **)&vs, &c) != 0) {
	return (1);
	}
	printf("%s%s,name=%s,state=%s,%s ", POOL_MEASUREMENT, tags,
	pool_name, zpool_state_to_name((vdev_state_t)vs->vs_state,
	(vdev_aux_t)vs->vs_aux), vdev_desc);
	print_kv("alloc", vs->vs_alloc);
	print_kv(",free", vs->vs_space - vs->vs_alloc);
	print_kv(",size", vs->vs_space);
	print_kv(",read_bytes", vs->vs_bytes[ZIO_TYPE_READ]);
	print_kv(",read_errors", vs->vs_read_errors);
	print_kv(",read_ops", vs->vs_ops[ZIO_TYPE_READ]);
	print_kv(",write_bytes", vs->vs_bytes[ZIO_TYPE_WRITE]);
	print_kv(",write_errors", vs->vs_write_errors);
	print_kv(",write_ops", vs->vs_ops[ZIO_TYPE_WRITE]);
	print_kv(",checksum_errors", vs->vs_checksum_errors);
	print_kv(",fragmentation", vs->vs_fragmentation);
	printf(" %llu\n", (u_longlong_t)timestamp);
	return (0);
	}

	/*
	* vdev latency stats are histograms stored as nvlist arrays of uint64.
	* Latency stats include the ZIO scheduler classes plus lower-level
	* vdev latencies.
	*
	* In many cases, the top-level "root" view obscures the underlying
	* top-level vdev operations. For example, if a pool has a log, special,
	* or cache device, then each can behave very differently. It is useful
	* to see how each is responding.
	*/
	static int
	print_vdev_latency_stats(nvlist_t nvroot, const char pool_name,
	const char *parent_name)
	{
	uint_t c, end = 0;
	nvlist_t *nv_ex;
	char *vdev_desc = NULL;

	/* short_names become part of the metric name and are influxdb-ready */
	struct lat_lookup {
	char *name;
	char *short_name;
	uint64_t sum;
	uint64_t *array;
	};
	struct lat_lookup lat_type[] = {
	{ZPOOL_CONFIG_VDEV_TOT_R_LAT_HISTO, "total_read", 0},
	{ZPOOL_CONFIG_VDEV_TOT_W_LAT_HISTO, "total_write", 0},
	{ZPOOL_CONFIG_VDEV_DISK_R_LAT_HISTO, "disk_read", 0},
	{ZPOOL_CONFIG_VDEV_DISK_W_LAT_HISTO, "disk_write", 0},
	{ZPOOL_CONFIG_VDEV_SYNC_R_LAT_HISTO, "sync_read", 0},
	{ZPOOL_CONFIG_VDEV_SYNC_W_LAT_HISTO, "sync_write", 0},
	{ZPOOL_CONFIG_VDEV_ASYNC_R_LAT_HISTO, "async_read", 0},
	{ZPOOL_CONFIG_VDEV_ASYNC_W_LAT_HISTO, "async_write", 0},
	{ZPOOL_CONFIG_VDEV_SCRUB_LAT_HISTO, "scrub", 0},
	#ifdef ZPOOL_CONFIG_VDEV_TRIM_LAT_HISTO
	{ZPOOL_CONFIG_VDEV_TRIM_LAT_HISTO, "trim", 0},
	#endif
	{NULL, NULL}
	};

	if (nvlist_lookup_nvlist(nvroot,
	ZPOOL_CONFIG_VDEV_STATS_EX, &nv_ex) != 0) {
	return (6);
	}

	vdev_desc = get_vdev_desc(nvroot, parent_name);

	for (int i = 0; lat_type[i].name; i++) {
	if (nvlist_lookup_uint64_array(nv_ex,
	lat_type[i].name, &lat_type[i].array, &c) != 0) {
	fprintf(stderr, "error: can't get %s\n",
	lat_type[i].name);
	return (3);
	}
	/* end count count, all of the arrays are the same size */
	end = c - 1;
	}

	for (int bucket = 0; bucket <= end; bucket++) {
	if (bucket < MIN_LAT_INDEX) {
	/* don't print, but collect the sum */
	for (int i = 0; lat_type[i].name; i++) {
	lat_type[i].sum += lat_type[i].array[bucket];
	}
	continue;
	}
	if (bucket < end) {
	printf("%s%s,le=%0.6f,name=%s,%s ",
	POOL_LATENCY_MEASUREMENT, tags,
	(float)(1ULL << bucket) * 1e-9,
	pool_name, vdev_desc);
	} else {
	printf("%s%s,le=+Inf,name=%s,%s ",
	POOL_LATENCY_MEASUREMENT, tags, pool_name,
	vdev_desc);
	}
	for (int i = 0; lat_type[i].name; i++) {
	if (bucket <= MIN_LAT_INDEX \|\| sum_histogram_buckets) {
	lat_type[i].sum += lat_type[i].array[bucket];
	} else {
	lat_type[i].sum = lat_type[i].array[bucket];
	}
	print_kv(lat_type[i].short_name, lat_type[i].sum);
	if (lat_type[i + 1].name != NULL) {
	printf(",");
	}
	}
	printf(" %llu\n", (u_longlong_t)timestamp);
	}
	return (0);
	}

	/*
	* vdev request size stats are histograms stored as nvlist arrays of uint64.
	* Request size stats include the ZIO scheduler classes plus lower-level
	* vdev sizes. Both independent (ind) and aggregated (agg) sizes are reported.
	*
	* In many cases, the top-level "root" view obscures the underlying
	* top-level vdev operations. For example, if a pool has a log, special,
	* or cache device, then each can behave very differently. It is useful
	* to see how each is responding.
	*/
	static int
	print_vdev_size_stats(nvlist_t nvroot, const char pool_name,
	const char *parent_name)
	{
	uint_t c, end = 0;
	nvlist_t *nv_ex;
	char *vdev_desc = NULL;

	/* short_names become the field name */
	struct size_lookup {
	char *name;
	char *short_name;
	uint64_t sum;
	uint64_t *array;
	};
	struct size_lookup size_type[] = {
	{ZPOOL_CONFIG_VDEV_SYNC_IND_R_HISTO, "sync_read_ind"},
	{ZPOOL_CONFIG_VDEV_SYNC_IND_W_HISTO, "sync_write_ind"},
	{ZPOOL_CONFIG_VDEV_ASYNC_IND_R_HISTO, "async_read_ind"},
	{ZPOOL_CONFIG_VDEV_ASYNC_IND_W_HISTO, "async_write_ind"},
	{ZPOOL_CONFIG_VDEV_IND_SCRUB_HISTO, "scrub_read_ind"},
	{ZPOOL_CONFIG_VDEV_SYNC_AGG_R_HISTO, "sync_read_agg"},
	{ZPOOL_CONFIG_VDEV_SYNC_AGG_W_HISTO, "sync_write_agg"},
	{ZPOOL_CONFIG_VDEV_ASYNC_AGG_R_HISTO, "async_read_agg"},
	{ZPOOL_CONFIG_VDEV_ASYNC_AGG_W_HISTO, "async_write_agg"},
	{ZPOOL_CONFIG_VDEV_AGG_SCRUB_HISTO, "scrub_read_agg"},
	#ifdef ZPOOL_CONFIG_VDEV_IND_TRIM_HISTO
	{ZPOOL_CONFIG_VDEV_IND_TRIM_HISTO, "trim_write_ind"},
	{ZPOOL_CONFIG_VDEV_AGG_TRIM_HISTO, "trim_write_agg"},
	#endif
	{NULL, NULL}
	};

	if (nvlist_lookup_nvlist(nvroot,
	ZPOOL_CONFIG_VDEV_STATS_EX, &nv_ex) != 0) {
	return (6);
	}

	vdev_desc = get_vdev_desc(nvroot, parent_name);

	for (int i = 0; size_type[i].name; i++) {
	if (nvlist_lookup_uint64_array(nv_ex, size_type[i].name,
	&size_type[i].array, &c) != 0) {
	fprintf(stderr, "error: can't get %s\n",
	size_type[i].name);
	return (3);
	}
	/* end count count, all of the arrays are the same size */
	end = c - 1;
	}

	for (int bucket = 0; bucket <= end; bucket++) {
	if (bucket < MIN_SIZE_INDEX) {
	/* don't print, but collect the sum */
	for (int i = 0; size_type[i].name; i++) {
	size_type[i].sum += size_type[i].array[bucket];
	}
	continue;
	}

	if (bucket < end) {
	printf("%s%s,le=%llu,name=%s,%s ",
	POOL_IO_SIZE_MEASUREMENT, tags, 1ULL << bucket,
	pool_name, vdev_desc);
	} else {
	printf("%s%s,le=+Inf,name=%s,%s ",
	POOL_IO_SIZE_MEASUREMENT, tags, pool_name,
	vdev_desc);
	}
	for (int i = 0; size_type[i].name; i++) {
	if (bucket <= MIN_SIZE_INDEX \|\| sum_histogram_buckets) {
	size_type[i].sum += size_type[i].array[bucket];
	} else {
	size_type[i].sum = size_type[i].array[bucket];
	}
	print_kv(size_type[i].short_name, size_type[i].sum);
	if (size_type[i + 1].name != NULL) {
	printf(",");
	}
	}
	printf(" %llu\n", (u_longlong_t)timestamp);
	}
	return (0);
	}

	/*
	* ZIO scheduler queue stats are stored as gauges. This is unfortunate
	* because the values can change very rapidly and any point-in-time
	* value will quickly be obsoleted. It is also not easy to downsample.
	* Thus only the top-level queue stats might be beneficial... maybe.
	*/
	static int
	print_queue_stats(nvlist_t nvroot, const char pool_name,
	const char *parent_name)
	{
	nvlist_t *nv_ex;
	uint64_t value;

	/* short_names are used for the field name */
	struct queue_lookup {
	char *name;
	char *short_name;
	};
	struct queue_lookup queue_type[] = {
	{ZPOOL_CONFIG_VDEV_SYNC_R_ACTIVE_QUEUE, "sync_r_active"},
	{ZPOOL_CONFIG_VDEV_SYNC_W_ACTIVE_QUEUE, "sync_w_active"},
	{ZPOOL_CONFIG_VDEV_ASYNC_R_ACTIVE_QUEUE, "async_r_active"},
	{ZPOOL_CONFIG_VDEV_ASYNC_W_ACTIVE_QUEUE, "async_w_active"},
	{ZPOOL_CONFIG_VDEV_SCRUB_ACTIVE_QUEUE, "async_scrub_active"},
	{ZPOOL_CONFIG_VDEV_SYNC_R_PEND_QUEUE, "sync_r_pend"},
	{ZPOOL_CONFIG_VDEV_SYNC_W_PEND_QUEUE, "sync_w_pend"},
	{ZPOOL_CONFIG_VDEV_ASYNC_R_PEND_QUEUE, "async_r_pend"},
	{ZPOOL_CONFIG_VDEV_ASYNC_W_PEND_QUEUE, "async_w_pend"},
	{ZPOOL_CONFIG_VDEV_SCRUB_PEND_QUEUE, "async_scrub_pend"},
	{NULL, NULL}
	};

	if (nvlist_lookup_nvlist(nvroot,
	ZPOOL_CONFIG_VDEV_STATS_EX, &nv_ex) != 0) {
	return (6);
	}

	printf("%s%s,name=%s,%s ", POOL_QUEUE_MEASUREMENT, tags, pool_name,
	get_vdev_desc(nvroot, parent_name));
	for (int i = 0; queue_type[i].name; i++) {
	if (nvlist_lookup_uint64(nv_ex,
	queue_type[i].name, &value) != 0) {
	fprintf(stderr, "error: can't get %s\n",
	queue_type[i].name);
	return (3);
	}
	print_kv(queue_type[i].short_name, value);
	if (queue_type[i + 1].name != NULL) {
	printf(",");
	}
	}
	printf(" %llu\n", (u_longlong_t)timestamp);
	return (0);
	}

	/*
	* top-level vdev stats are at the pool level
	*/
	static int
	print_top_level_vdev_stats(nvlist_t nvroot, const char pool_name)
	{
	nvlist_t *nv_ex;
	uint64_t value;

	/* short_names become part of the metric name */
	struct queue_lookup {
	char *name;
	char *short_name;
	};
	struct queue_lookup queue_type[] = {
	{ZPOOL_CONFIG_VDEV_SYNC_R_ACTIVE_QUEUE, "sync_r_active_queue"},
	{ZPOOL_CONFIG_VDEV_SYNC_W_ACTIVE_QUEUE, "sync_w_active_queue"},
	{ZPOOL_CONFIG_VDEV_ASYNC_R_ACTIVE_QUEUE, "async_r_active_queue"},
	{ZPOOL_CONFIG_VDEV_ASYNC_W_ACTIVE_QUEUE, "async_w_active_queue"},
	{ZPOOL_CONFIG_VDEV_SCRUB_ACTIVE_QUEUE, "async_scrub_active_queue"},
	{ZPOOL_CONFIG_VDEV_SYNC_R_PEND_QUEUE, "sync_r_pend_queue"},
	{ZPOOL_CONFIG_VDEV_SYNC_W_PEND_QUEUE, "sync_w_pend_queue"},
	{ZPOOL_CONFIG_VDEV_ASYNC_R_PEND_QUEUE, "async_r_pend_queue"},
	{ZPOOL_CONFIG_VDEV_ASYNC_W_PEND_QUEUE, "async_w_pend_queue"},
	{ZPOOL_CONFIG_VDEV_SCRUB_PEND_QUEUE, "async_scrub_pend_queue"},
	{NULL, NULL}
	};

	if (nvlist_lookup_nvlist(nvroot,
	ZPOOL_CONFIG_VDEV_STATS_EX, &nv_ex) != 0) {
	return (6);
	}

	printf("%s%s,name=%s,vdev=root ", VDEV_MEASUREMENT, tags,
	pool_name);
	for (int i = 0; queue_type[i].name; i++) {
	if (nvlist_lookup_uint64(nv_ex,
	queue_type[i].name, &value) != 0) {
	fprintf(stderr, "error: can't get %s\n",
	queue_type[i].name);
	return (3);
	}
	if (i > 0)
	printf(",");
	print_kv(queue_type[i].short_name, value);
	}

	printf(" %llu\n", (u_longlong_t)timestamp);
	return (0);
	}

	/*
	* recursive stats printer
	*/
	static int
	print_recursive_stats(stat_printer_f func, nvlist_t *nvroot,
	const char pool_name, const char parent_name, int descend)
	{
	uint_t c, children;
	nvlist_t **child;
	char vdev_name[256];
	int err;

	err = func(nvroot, pool_name, parent_name);
	if (err)
	return (err);

	if (descend && nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_CHILDREN,
	&child, &children) == 0) {
	(void) strlcpy(vdev_name, get_vdev_name(nvroot, parent_name),
	sizeof (vdev_name));

	for (c = 0; c < children; c++) {
	print_recursive_stats(func, child[c], pool_name,
	vdev_name, descend);
	}
	}
	return (0);
	}

	/*
	* call-back to print the stats from the pool config
	*
	* Note: if the pool is broken, this can hang indefinitely and perhaps in an
	* unkillable state.
	*/
	static int
	print_stats(zpool_handle_t zhp, void data)
	{
	uint_t c;
	int err;
	boolean_t missing;
	nvlist_t config, nvroot;
	vdev_stat_t *vs;
	struct timespec tv;
	char *pool_name;

	/* if not this pool return quickly */
	if (data &&
	strncmp(data, zhp->zpool_name, ZFS_MAX_DATASET_NAME_LEN) != 0) {
	zpool_close(zhp);
	return (0);
	}

	if (zpool_refresh_stats(zhp, &missing) != 0) {
	zpool_close(zhp);
	return (1);
	}

	config = zpool_get_config(zhp, NULL);
	if (clock_gettime(CLOCK_REALTIME, &tv) != 0)
	timestamp = (uint64_t)time(NULL) * 1000000000;
	else
	timestamp =
	((uint64_t)tv.tv_sec * 1000000000) + (uint64_t)tv.tv_nsec;

	if (nvlist_lookup_nvlist(
	config, ZPOOL_CONFIG_VDEV_TREE, &nvroot) != 0) {
	zpool_close(zhp);
	return (2);
	}
	if (nvlist_lookup_uint64_array(nvroot, ZPOOL_CONFIG_VDEV_STATS,
	(uint64_t **)&vs, &c) != 0) {
	zpool_close(zhp);
	return (3);
	}

	pool_name = escape_string(zhp->zpool_name);
	err = print_recursive_stats(print_summary_stats, nvroot,
	pool_name, NULL, 1);
	/* if any of these return an error, skip the rest */
	if (err == 0)
	err = print_top_level_vdev_stats(nvroot, pool_name);

	if (no_histograms == 0) {
	if (err == 0)
	err = print_recursive_stats(print_vdev_latency_stats, nvroot,
	pool_name, NULL, 1);
	if (err == 0)
	err = print_recursive_stats(print_vdev_size_stats, nvroot,
	pool_name, NULL, 1);
	if (err == 0)
	err = print_recursive_stats(print_queue_stats, nvroot,
	pool_name, NULL, 0);
	}
	if (err == 0)
	err = print_scan_status(nvroot, pool_name);

	free(pool_name);
	zpool_close(zhp);
	return (err);
	}

	static void
	usage(char *name)
	{
	fprintf(stderr, "usage: %s [--execd][--no-histograms]"
	"[--sum-histogram-buckets] [--signed-int] [poolname]\n", name);
	exit(EXIT_FAILURE);
	}

	int
	main(int argc, char *argv[])
	{
	int opt;
	int ret = 8;
	char *line = NULL;
	size_t len, tagslen = 0;
	struct option long_options[] = {
	{"execd", no_argument, NULL, 'e'},
	{"help", no_argument, NULL, 'h'},
	{"no-histograms", no_argument, NULL, 'n'},
	{"signed-int", no_argument, NULL, 'i'},
	{"sum-histogram-buckets", no_argument, NULL, 's'},
	{"tags", required_argument, NULL, 't'},
	{0, 0, 0, 0}
	};
	while ((opt = getopt_long(
	argc, argv, "ehinst:", long_options, NULL)) != -1) {
	switch (opt) {
	case 'e':
	execd_mode = 1;
	break;
	case 'i':
	metric_data_type = 'i';
	metric_value_mask = INT64_MAX;
	break;
	case 'n':
	no_histograms = 1;
	break;
	case 's':
	sum_histogram_buckets = 1;
	break;
	case 't':
	tagslen = strlen(optarg) + 2;
	tags = calloc(tagslen, 1);
	if (tags == NULL) {
	fprintf(stderr,
	"error: cannot allocate memory "
	"for tags\n");
	exit(1);
	}
	(void) snprintf(tags, tagslen, ",%s", optarg);
	break;
	default:
	usage(argv[0]);
	}
	}

	libzfs_handle_t *g_zfs;
	if ((g_zfs = libzfs_init()) == NULL) {
	fprintf(stderr,
	"error: cannot initialize libzfs. "
	"Is the zfs module loaded or zrepl running?\n");
	exit(EXIT_FAILURE);
	}
	if (execd_mode == 0) {
	ret = zpool_iter(g_zfs, print_stats, argv[optind]);
	return (ret);
	}
	while (getline(&line, &len, stdin) != -1) {
	ret = zpool_iter(g_zfs, print_stats, argv[optind]);
	fflush(stdout);
	}
	return (ret);
	}
	diff --git a/sys/contrib/openzfs/config/Rules.am b/sys/contrib/openzfs/config/Rules.am
	index 99587eab2bf8..3b24e3630102 100644
	--- a/sys/contrib/openzfs/config/Rules.am
	+++ b/sys/contrib/openzfs/config/Rules.am
	@@ -1,64 +1,64 @@
	#
	# Default build rules for all user space components, every Makefile.am
	# should include these rules and override or extend them as needed.
	#

	PHONY =
	DEFAULT_INCLUDES = \
	-include $(top_builddir)/zfs_config.h \
	-I$(top_builddir)/include \
	-I$(top_srcdir)/include \
	-I$(top_srcdir)/module/icp/include \
	-I$(top_srcdir)/lib/libspl/include

	if BUILD_LINUX
	DEFAULT_INCLUDES += \
	-I$(top_srcdir)/lib/libspl/include/os/linux
	endif

	if BUILD_FREEBSD
	DEFAULT_INCLUDES += \
	-I$(top_srcdir)/lib/libspl/include/os/freebsd
	endif

	AM_LIBTOOLFLAGS = --silent

	AM_CFLAGS = -std=gnu99 -Wall -Wstrict-prototypes -Wmissing-prototypes
	AM_CFLAGS += -fno-strict-aliasing
	AM_CFLAGS += $(NO_OMIT_FRAME_POINTER)
	+AM_CFLAGS += $(IMPLICIT_FALLTHROUGH)
	AM_CFLAGS += $(DEBUG_CFLAGS)
	AM_CFLAGS += $(ASAN_CFLAGS)
	AM_CFLAGS += $(CODE_COVERAGE_CFLAGS) $(NO_FORMAT_ZERO_LENGTH)
	if BUILD_FREEBSD
	AM_CFLAGS += -fPIC -Werror -Wno-unknown-pragmas -Wno-enum-conversion
	AM_CFLAGS += -include $(top_srcdir)/include/os/freebsd/spl/sys/ccompile.h
	AM_CFLAGS += -I/usr/include -I/usr/local/include
	endif

	AM_CPPFLAGS = -D_GNU_SOURCE
	AM_CPPFLAGS += -D_REENTRANT
	AM_CPPFLAGS += -D_FILE_OFFSET_BITS=64
	AM_CPPFLAGS += -D_LARGEFILE64_SOURCE
	-AM_CPPFLAGS += -DHAVE_LARGE_STACKS=1
	AM_CPPFLAGS += -DLIBEXECDIR=\"$(libexecdir)\"
	AM_CPPFLAGS += -DRUNSTATEDIR=\"$(runstatedir)\"
	AM_CPPFLAGS += -DSBINDIR=\"$(sbindir)\"
	AM_CPPFLAGS += -DSYSCONFDIR=\"$(sysconfdir)\"
	AM_CPPFLAGS += -DPKGDATADIR=\"$(pkgdatadir)\"
	AM_CPPFLAGS += $(DEBUG_CPPFLAGS)
	AM_CPPFLAGS += $(CODE_COVERAGE_CPPFLAGS)
	if BUILD_LINUX
	AM_CPPFLAGS += -DTEXT_DOMAIN=\"zfs-linux-user\"
	endif
	if BUILD_FREEBSD
	AM_CPPFLAGS += -DTEXT_DOMAIN=\"zfs-freebsd-user\"
	endif

	AM_LDFLAGS = $(DEBUG_LDFLAGS)
	AM_LDFLAGS += $(ASAN_LDFLAGS)

	if BUILD_FREEBSD
	AM_LDFLAGS += -fstack-protector-strong -shared
	AM_LDFLAGS += -Wl,-x -Wl,--fatal-warnings -Wl,--warn-shared-textrel
	AM_LDFLAGS += -lm
	endif
	diff --git a/sys/contrib/openzfs/config/always-compiler-options.m4 b/sys/contrib/openzfs/config/always-compiler-options.m4
	index a84123317989..ce84f7e60684 100644
	--- a/sys/contrib/openzfs/config/always-compiler-options.m4
	+++ b/sys/contrib/openzfs/config/always-compiler-options.m4
	@@ -1,204 +1,227 @@
	dnl #
	dnl # Enabled -fsanitize=address if supported by gcc.
	dnl #
	dnl # LDFLAGS needs -fsanitize=address at all times so libraries compiled with
	dnl # it will be linked successfully. CFLAGS will vary by binary being built.
	dnl #
	dnl # The ASAN_OPTIONS environment variable can be used to further control
	dnl # the behavior of binaries and libraries build with -fsanitize=address.
	dnl #
	AC_DEFUN([ZFS_AC_CONFIG_ALWAYS_CC_ASAN], [
	AC_MSG_CHECKING([whether to build with -fsanitize=address support])
	AC_ARG_ENABLE([asan],
	[AS_HELP_STRING([--enable-asan],
	[Enable -fsanitize=address support @<:@default=no@:>@])],
	[],
	[enable_asan=no])

	AM_CONDITIONAL([ASAN_ENABLED], [test x$enable_asan = xyes])
	AC_SUBST([ASAN_ENABLED], [$enable_asan])
	AC_MSG_RESULT($enable_asan)

	AS_IF([ test "$enable_asan" = "yes" ], [
	AC_MSG_CHECKING([whether $CC supports -fsanitize=address])
	saved_cflags="$CFLAGS"
	CFLAGS="$CFLAGS -Werror -fsanitize=address"
	AC_LINK_IFELSE([
	AC_LANG_SOURCE([[ int main() { return 0; } ]])
	], [
	ASAN_CFLAGS="-fsanitize=address"
	ASAN_LDFLAGS="-fsanitize=address"
	ASAN_ZFS="_with_asan"
	AC_MSG_RESULT([yes])
	], [
	AC_MSG_ERROR([$CC does not support -fsanitize=address])
	])
	CFLAGS="$saved_cflags"
	], [
	ASAN_CFLAGS=""
	ASAN_LDFLAGS=""
	ASAN_ZFS="_without_asan"
	])

	AC_SUBST([ASAN_CFLAGS])
	AC_SUBST([ASAN_LDFLAGS])
	AC_SUBST([ASAN_ZFS])
	])

	dnl #
	dnl # Check if gcc supports -Wframe-larger-than=<size> option.
	dnl #
	AC_DEFUN([ZFS_AC_CONFIG_ALWAYS_CC_FRAME_LARGER_THAN], [
	AC_MSG_CHECKING([whether $CC supports -Wframe-larger-than=<size>])

	saved_flags="$CFLAGS"
	CFLAGS="$CFLAGS -Werror -Wframe-larger-than=4096"

	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [])], [
	FRAME_LARGER_THAN="-Wframe-larger-than=4096"
	AC_MSG_RESULT([yes])
	], [
	FRAME_LARGER_THAN=""
	AC_MSG_RESULT([no])
	])

	CFLAGS="$saved_flags"
	AC_SUBST([FRAME_LARGER_THAN])
	])

	dnl #
	dnl # Check if gcc supports -Wno-format-truncation option.
	dnl #
	AC_DEFUN([ZFS_AC_CONFIG_ALWAYS_CC_NO_FORMAT_TRUNCATION], [
	AC_MSG_CHECKING([whether $CC supports -Wno-format-truncation])

	saved_flags="$CFLAGS"
	CFLAGS="$CFLAGS -Werror -Wno-format-truncation"

	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [])], [
	NO_FORMAT_TRUNCATION=-Wno-format-truncation
	AC_MSG_RESULT([yes])
	], [
	NO_FORMAT_TRUNCATION=
	AC_MSG_RESULT([no])
	])

	CFLAGS="$saved_flags"
	AC_SUBST([NO_FORMAT_TRUNCATION])
	])

	dnl #
	dnl # Check if gcc supports -Wno-format-truncation option.
	dnl #
	AC_DEFUN([ZFS_AC_CONFIG_ALWAYS_CC_NO_FORMAT_ZERO_LENGTH], [
	AC_MSG_CHECKING([whether $CC supports -Wno-format-zero-length])

	saved_flags="$CFLAGS"
	CFLAGS="$CFLAGS -Werror -Wno-format-zero-length"

	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [])], [
	NO_FORMAT_ZERO_LENGTH=-Wno-format-zero-length
	AC_MSG_RESULT([yes])
	], [
	NO_FORMAT_ZERO_LENGTH=
	AC_MSG_RESULT([no])
	])

	CFLAGS="$saved_flags"
	AC_SUBST([NO_FORMAT_ZERO_LENGTH])
	])


	dnl #
	dnl # Check if gcc supports -Wno-bool-compare option.
	dnl #
	dnl # We actually invoke gcc with the -Wbool-compare option
	dnl # and infer the 'no-' version does or doesn't exist based upon
	dnl # the results. This is required because when checking any of
	dnl # no- prefixed options gcc always returns success.
	dnl #
	AC_DEFUN([ZFS_AC_CONFIG_ALWAYS_CC_NO_BOOL_COMPARE], [
	AC_MSG_CHECKING([whether $CC supports -Wno-bool-compare])

	saved_flags="$CFLAGS"
	CFLAGS="$CFLAGS -Werror -Wbool-compare"

	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [])], [
	NO_BOOL_COMPARE=-Wno-bool-compare
	AC_MSG_RESULT([yes])
	], [
	NO_BOOL_COMPARE=
	AC_MSG_RESULT([no])
	])

	CFLAGS="$saved_flags"
	AC_SUBST([NO_BOOL_COMPARE])
	])

	dnl #
	dnl # Check if gcc supports -Wno-unused-but-set-variable option.
	dnl #
	dnl # We actually invoke gcc with the -Wunused-but-set-variable option
	dnl # and infer the 'no-' version does or doesn't exist based upon
	dnl # the results. This is required because when checking any of
	dnl # no- prefixed options gcc always returns success.
	dnl #
	AC_DEFUN([ZFS_AC_CONFIG_ALWAYS_CC_NO_UNUSED_BUT_SET_VARIABLE], [
	AC_MSG_CHECKING([whether $CC supports -Wno-unused-but-set-variable])

	saved_flags="$CFLAGS"
	CFLAGS="$CFLAGS -Werror -Wunused-but-set-variable"

	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [])], [
	NO_UNUSED_BUT_SET_VARIABLE=-Wno-unused-but-set-variable
	AC_MSG_RESULT([yes])
	], [
	NO_UNUSED_BUT_SET_VARIABLE=
	AC_MSG_RESULT([no])
	])

	CFLAGS="$saved_flags"
	AC_SUBST([NO_UNUSED_BUT_SET_VARIABLE])
	])

	+dnl #
	+dnl # Check if gcc supports -Wimplicit-fallthrough option.
	+dnl #
	+AC_DEFUN([ZFS_AC_CONFIG_ALWAYS_CC_IMPLICIT_FALLTHROUGH], [
	+ AC_MSG_CHECKING([whether $CC supports -Wimplicit-fallthrough])
	+
	+ saved_flags="$CFLAGS"
	+ CFLAGS="$CFLAGS -Werror -Wimplicit-fallthrough"
	+
	+ AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [])], [
	+ IMPLICIT_FALLTHROUGH=-Wimplicit-fallthrough
	+ AC_DEFINE([HAVE_IMPLICIT_FALLTHROUGH], 1,
	+ [Define if compiler supports -Wimplicit-fallthrough])
	+ AC_MSG_RESULT([yes])
	+ ], [
	+ IMPLICIT_FALLTHROUGH=
	+ AC_MSG_RESULT([no])
	+ ])
	+
	+ CFLAGS="$saved_flags"
	+ AC_SUBST([IMPLICIT_FALLTHROUGH])
	+])
	+
	dnl #
	dnl # Check if gcc supports -fno-omit-frame-pointer option.
	dnl #
	AC_DEFUN([ZFS_AC_CONFIG_ALWAYS_CC_NO_OMIT_FRAME_POINTER], [
	AC_MSG_CHECKING([whether $CC supports -fno-omit-frame-pointer])

	saved_flags="$CFLAGS"
	CFLAGS="$CFLAGS -Werror -fno-omit-frame-pointer"

	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [])], [
	NO_OMIT_FRAME_POINTER=-fno-omit-frame-pointer
	AC_MSG_RESULT([yes])
	], [
	NO_OMIT_FRAME_POINTER=
	AC_MSG_RESULT([no])
	])

	CFLAGS="$saved_flags"
	AC_SUBST([NO_OMIT_FRAME_POINTER])
	])

	dnl #
	dnl # Check if cc supports -fno-ipa-sra option.
	dnl #
	AC_DEFUN([ZFS_AC_CONFIG_ALWAYS_CC_NO_IPA_SRA], [
	AC_MSG_CHECKING([whether $CC supports -fno-ipa-sra])

	saved_flags="$CFLAGS"
	CFLAGS="$CFLAGS -Werror -fno-ipa-sra"

	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [])], [
	NO_IPA_SRA=-fno-ipa-sra
	AC_MSG_RESULT([yes])
	], [
	NO_IPA_SRA=
	AC_MSG_RESULT([no])
	])

	CFLAGS="$saved_flags"
	AC_SUBST([NO_IPA_SRA])
	])
	diff --git a/sys/contrib/openzfs/config/always-pyzfs.m4 b/sys/contrib/openzfs/config/always-pyzfs.m4
	index 76e07b593df2..fa39fd88519c 100644
	--- a/sys/contrib/openzfs/config/always-pyzfs.m4
	+++ b/sys/contrib/openzfs/config/always-pyzfs.m4
	@@ -1,105 +1,120 @@
	dnl #
	dnl # ZFS_AC_PYTHON_MODULE(module_name, [action-if-true], [action-if-false])
	dnl #
	dnl # Checks for Python module. Freely inspired by AX_PYTHON_MODULE
	dnl # https://www.gnu.org/software/autoconf-archive/ax_python_module.html
	dnl # Required by ZFS_AC_CONFIG_ALWAYS_PYZFS.
	dnl #
	AC_DEFUN([ZFS_AC_PYTHON_MODULE], [
	PYTHON_NAME=$(basename $PYTHON)
	AC_MSG_CHECKING([for $PYTHON_NAME module: $1])
	AS_IF([$PYTHON -c "import $1" 2>/dev/null], [
	AC_MSG_RESULT(yes)
	m4_ifvaln([$2], [$2])
	], [
	AC_MSG_RESULT(no)
	m4_ifvaln([$3], [$3])
	])
	])

	dnl #
	dnl # Determines if pyzfs can be built, requires Python 2.7 or later.
	dnl #
	AC_DEFUN([ZFS_AC_CONFIG_ALWAYS_PYZFS], [
	AC_ARG_ENABLE([pyzfs],
	AS_HELP_STRING([--enable-pyzfs],
	[install libzfs_core python bindings @<:@default=check@:>@]),
	[enable_pyzfs=$enableval],
	[enable_pyzfs=check])

	dnl #
	dnl # Packages for pyzfs specifically enabled/disabled.
	dnl #
	AS_IF([test "x$enable_pyzfs" != xcheck], [
	AS_IF([test "x$enable_pyzfs" = xyes], [
	DEFINE_PYZFS='--with pyzfs'
	], [
	DEFINE_PYZFS='--without pyzfs'
	])
	], [
	AS_IF([test "$PYTHON" != :], [
	DEFINE_PYZFS=''
	], [
	enable_pyzfs=no
	DEFINE_PYZFS='--without pyzfs'
	])
	])
	AC_SUBST(DEFINE_PYZFS)

	+ dnl #
	+ dnl # Python "packaging" (or, failing that, "distlib") module is required to build and install pyzfs
	+ dnl #
	+ AS_IF([test "x$enable_pyzfs" = xcheck -o "x$enable_pyzfs" = xyes], [
	+ ZFS_AC_PYTHON_MODULE([packaging], [], [
	+ ZFS_AC_PYTHON_MODULE([distlib], [], [
	+ AS_IF([test "x$enable_pyzfs" = xyes], [
	+ AC_MSG_ERROR("Python $PYTHON_VERSION packaging and distlib modules are not installed")
	+ ], [test "x$enable_pyzfs" != xno], [
	+ enable_pyzfs=no
	+ ])
	+ ])
	+ ])
	+ ])
	+
	dnl #
	dnl # Require python-devel libraries
	dnl #
	AS_IF([test "x$enable_pyzfs" = xcheck -o "x$enable_pyzfs" = xyes], [
	AS_CASE([$PYTHON_VERSION],
	[3.*], [PYTHON_REQUIRED_VERSION=">= '3.4.0'"],
	[2.*], [PYTHON_REQUIRED_VERSION=">= '2.7.0'"],
	[AC_MSG_ERROR("Python $PYTHON_VERSION unknown")]
	)

	AX_PYTHON_DEVEL([$PYTHON_REQUIRED_VERSION], [
	AS_IF([test "x$enable_pyzfs" = xyes], [
	AC_MSG_ERROR("Python $PYTHON_REQUIRED_VERSION development library is not installed")
	], [test "x$enable_pyzfs" != xno], [
	enable_pyzfs=no
	])
	])
	])

	dnl #
	dnl # Python "setuptools" module is required to build and install pyzfs
	dnl #
	AS_IF([test "x$enable_pyzfs" = xcheck -o "x$enable_pyzfs" = xyes], [
	ZFS_AC_PYTHON_MODULE([setuptools], [], [
	AS_IF([test "x$enable_pyzfs" = xyes], [
	AC_MSG_ERROR("Python $PYTHON_VERSION setuptools is not installed")
	], [test "x$enable_pyzfs" != xno], [
	enable_pyzfs=no
	])
	])
	])

	dnl #
	dnl # Python "cffi" module is required to run pyzfs
	dnl #
	AS_IF([test "x$enable_pyzfs" = xcheck -o "x$enable_pyzfs" = xyes], [
	ZFS_AC_PYTHON_MODULE([cffi], [], [
	AS_IF([test "x$enable_pyzfs" = xyes], [
	AC_MSG_ERROR("Python $PYTHON_VERSION cffi is not installed")
	], [test "x$enable_pyzfs" != xno], [
	enable_pyzfs=no
	])
	])
	])

	dnl #
	dnl # Set enable_pyzfs to 'yes' if every check passed
	dnl #
	AS_IF([test "x$enable_pyzfs" = xcheck], [enable_pyzfs=yes])

	AM_CONDITIONAL([PYZFS_ENABLED], [test "x$enable_pyzfs" = xyes])
	AC_SUBST([PYZFS_ENABLED], [$enable_pyzfs])
	AC_SUBST(pythonsitedir, [$PYTHON_SITE_PKG])

	AC_MSG_CHECKING([whether to enable pyzfs: ])
	AC_MSG_RESULT($enable_pyzfs)
	])
	diff --git a/sys/contrib/openzfs/config/ax_python_devel.m4 b/sys/contrib/openzfs/config/ax_python_devel.m4
	index faf6c2b0d7ef..fcf73dc20880 100644
	--- a/sys/contrib/openzfs/config/ax_python_devel.m4
	+++ b/sys/contrib/openzfs/config/ax_python_devel.m4
	@@ -1,344 +1,365 @@
	# ===========================================================================
	# https://www.gnu.org/software/autoconf-archive/ax_python_devel.html
	# ===========================================================================
	#
	# SYNOPSIS
	#
	# AX_PYTHON_DEVEL([version], [action-if-not-found])
	#
	# DESCRIPTION
	#
	# Note: Defines as a precious variable "PYTHON_VERSION". Don't override it
	# in your configure.ac.
	#
	# Note: this is a slightly modified version of the original AX_PYTHON_DEVEL
	# macro which accepts an additional [action-if-not-found] argument. This
	# allow to detect if Python development is available without aborting the
	# configure phase with an hard error in case it is not.
	#
	# This macro checks for Python and tries to get the include path to
	# 'Python.h'. It provides the $(PYTHON_CPPFLAGS) and $(PYTHON_LIBS) output
	# variables. It also exports $(PYTHON_EXTRA_LIBS) and
	# $(PYTHON_EXTRA_LDFLAGS) for embedding Python in your code.
	#
	# You can search for some particular version of Python by passing a
	# parameter to this macro, for example ">= '2.3.1'", or "== '2.4'". Please
	# note that you have to pass also an operator along with the version to
	# match, and pay special attention to the single quotes surrounding the
	# version number. Don't use "PYTHON_VERSION" for this: that environment
	# variable is declared as precious and thus reserved for the end-user.
	#
	# This macro should work for all versions of Python >= 2.1.0. As an end
	# user, you can disable the check for the python version by setting the
	# PYTHON_NOVERSIONCHECK environment variable to something else than the
	# empty string.
	#
	# If you need to use this macro for an older Python version, please
	# contact the authors. We're always open for feedback.
	#
	# LICENSE
	#
	# Copyright (c) 2009 Sebastian Huber <sebastian-huber@web.de>
	# Copyright (c) 2009 Alan W. Irwin
	# Copyright (c) 2009 Rafael Laboissiere <rafael@laboissiere.net>
	# Copyright (c) 2009 Andrew Collier
	# Copyright (c) 2009 Matteo Settenvini <matteo@member.fsf.org>
	# Copyright (c) 2009 Horst Knorr <hk_classes@knoda.org>
	# Copyright (c) 2013 Daniel Mullner <muellner@math.stanford.edu>
	# Copyright (c) 2018 loli10K <ezomori.nozomu@gmail.com>
	#
	# This program 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 3 of the License, or (at your
	# option) any later version.
	#
	# This program 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 this program. If not, see <https://www.gnu.org/licenses/>.
	#
	# As a special exception, the respective Autoconf Macro's copyright owner
	# gives unlimited permission to copy, distribute and modify the configure
	# scripts that are the output of Autoconf when processing the Macro. You
	# need not follow the terms of the GNU General Public License when using
	# or distributing such scripts, even though portions of the text of the
	# Macro appear in them. The GNU General Public License (GPL) does govern
	# all other use of the material that constitutes the Autoconf Macro.
	#
	# This special exception to the GPL applies to versions of the Autoconf
	# Macro released by the Autoconf Archive. When you make and distribute a
	# modified version of the Autoconf Macro, you may extend this special
	# exception to the GPL to apply to your modified version as well.

	#serial 21

	AU_ALIAS([AC_PYTHON_DEVEL], [AX_PYTHON_DEVEL])
	AC_DEFUN([AX_PYTHON_DEVEL],[
	#
	# Allow the use of a (user set) custom python version
	#
	AC_ARG_VAR([PYTHON_VERSION],[The installed Python
	version to use, for example '2.3'. This string
	will be appended to the Python interpreter
	canonical name.])

	AC_PATH_PROG([PYTHON],[python[$PYTHON_VERSION]])
	if test -z "$PYTHON"; then
	m4_ifvaln([$2],[$2],[
	AC_MSG_ERROR([Cannot find python$PYTHON_VERSION in your system path])
	PYTHON_VERSION=""
	])
	fi

	#
	# Check for a version of Python >= 2.1.0
	#
	AC_MSG_CHECKING([for a version of Python >= '2.1.0'])
	- ac_supports_python_ver=`$PYTHON -c "import sys; \
	- ver = sys.version.split ()[[0]]; \
	- print (ver >= '2.1.0')"`
	+ ac_supports_python_ver=`cat<<EOD \| $PYTHON -
	+from __future__ import print_function;
	+import sys;
	+try:
	+ from packaging import version;
	+except ImportError:
	+ from distlib import version;
	+ver = sys.version.split ()[[0]];
	+(tst_cmp, tst_ver) = ">= '2.1.0'".split ();
	+tst_ver = tst_ver.strip ("'");
	+eval ("print (version.LegacyVersion (ver)"+ tst_cmp +"version.LegacyVersion (tst_ver))")
	+EOD`
	if test "$ac_supports_python_ver" != "True"; then
	if test -z "$PYTHON_NOVERSIONCHECK"; then
	AC_MSG_RESULT([no])
	m4_ifvaln([$2],[$2],[
	AC_MSG_FAILURE([
	This version of the AC@&t@_PYTHON_DEVEL macro
	doesn't work properly with versions of Python before
	2.1.0. You may need to re-run configure, setting the
	variables PYTHON_CPPFLAGS, PYTHON_LIBS, PYTHON_SITE_PKG,
	PYTHON_EXTRA_LIBS and PYTHON_EXTRA_LDFLAGS by hand.
	Moreover, to disable this check, set PYTHON_NOVERSIONCHECK
	to something else than an empty string.
	])
	])
	else
	AC_MSG_RESULT([skip at user request])
	fi
	else
	AC_MSG_RESULT([yes])
	fi

	#
	# if the macro parameter ``version'' is set, honour it
	#
	if test -n "$1"; then
	AC_MSG_CHECKING([for a version of Python $1])
	- ac_supports_python_ver=`$PYTHON -c "import sys; \
	- ver = sys.version.split ()[[0]]; \
	- print (ver $1)"`
	+ # Why the strip ()? Because if we don't, version.parse
	+ # will, for example, report 3.10.0 >= '3.11.0'
	+ ac_supports_python_ver=`cat<<EOD \| $PYTHON -
	+
	+from __future__ import print_function;
	+import sys;
	+try:
	+ from packaging import version;
	+except ImportError:
	+ from distlib import version;
	+ver = sys.version.split ()[[0]];
	+(tst_cmp, tst_ver) = "$1".split ();
	+tst_ver = tst_ver.strip ("'");
	+eval ("print (version.LegacyVersion (ver)"+ tst_cmp +"version.LegacyVersion (tst_ver))")
	+EOD`
	if test "$ac_supports_python_ver" = "True"; then
	AC_MSG_RESULT([yes])
	else
	AC_MSG_RESULT([no])
	m4_ifvaln([$2],[$2],[
	AC_MSG_ERROR([this package requires Python $1.
	If you have it installed, but it isn't the default Python
	interpreter in your system path, please pass the PYTHON_VERSION
	variable to configure. See ``configure --help'' for reference.
	])
	PYTHON_VERSION=""
	])
	fi
	fi

	#
	# Check if you have distutils, else fail
	#
	AC_MSG_CHECKING([for the distutils Python package])
	if ac_distutils_result=`$PYTHON -c "import distutils" 2>&1`; then
	AC_MSG_RESULT([yes])
	else
	AC_MSG_RESULT([no])
	m4_ifvaln([$2],[$2],[
	AC_MSG_ERROR([cannot import Python module "distutils".
	Please check your Python installation. The error was:
	$ac_distutils_result])
	PYTHON_VERSION=""
	])
	fi

	#
	# Check for Python include path
	#
	AC_MSG_CHECKING([for Python include path])
	if test -z "$PYTHON_CPPFLAGS"; then
	python_path=`$PYTHON -c "import distutils.sysconfig; \
	print (distutils.sysconfig.get_python_inc ());"`
	plat_python_path=`$PYTHON -c "import distutils.sysconfig; \
	print (distutils.sysconfig.get_python_inc (plat_specific=1));"`
	if test -n "${python_path}"; then
	if test "${plat_python_path}" != "${python_path}"; then
	python_path="-I$python_path -I$plat_python_path"
	else
	python_path="-I$python_path"
	fi
	fi
	PYTHON_CPPFLAGS=$python_path
	fi
	AC_MSG_RESULT([$PYTHON_CPPFLAGS])
	AC_SUBST([PYTHON_CPPFLAGS])

	#
	# Check for Python library path
	#
	AC_MSG_CHECKING([for Python library path])
	if test -z "$PYTHON_LIBS"; then
	# (makes two attempts to ensure we've got a version number
	# from the interpreter)
	ac_python_version=`cat<<EOD \| $PYTHON -

	# join all versioning strings, on some systems
	# major/minor numbers could be in different list elements
	from distutils.sysconfig import *
	e = get_config_var('VERSION')
	if e is not None:
	print(e)
	EOD`

	if test -z "$ac_python_version"; then
	if test -n "$PYTHON_VERSION"; then
	ac_python_version=$PYTHON_VERSION
	else
	ac_python_version=`$PYTHON -c "import sys; \
	print (sys.version[[:3]])"`
	fi
	fi

	# Make the versioning information available to the compiler
	AC_DEFINE_UNQUOTED([HAVE_PYTHON], ["$ac_python_version"],
	[If available, contains the Python version number currently in use.])

	# First, the library directory:
	ac_python_libdir=`cat<<EOD \| $PYTHON -

	# There should be only one
	import distutils.sysconfig
	e = distutils.sysconfig.get_config_var('LIBDIR')
	if e is not None:
	print (e)
	EOD`

	# Now, for the library:
	ac_python_library=`cat<<EOD \| $PYTHON -

	import distutils.sysconfig
	c = distutils.sysconfig.get_config_vars()
	if 'LDVERSION' in c:
	print ('python'+c[['LDVERSION']])
	else:
	print ('python'+c[['VERSION']])
	EOD`

	# This small piece shamelessly adapted from PostgreSQL python macro;
	# credits goes to momjian, I think. I'd like to put the right name
	# in the credits, if someone can point me in the right direction... ?
	#
	if test -n "$ac_python_libdir" -a -n "$ac_python_library"
	then
	# use the official shared library
	ac_python_library=`echo "$ac_python_library" \| sed "s/^lib//"`
	PYTHON_LIBS="-L$ac_python_libdir -l$ac_python_library"
	else
	# old way: use libpython from python_configdir
	ac_python_libdir=`$PYTHON -c \
	"from distutils.sysconfig import get_python_lib as f; \
	import os; \
	print (os.path.join(f(plat_specific=1, standard_lib=1), 'config'));"`
	PYTHON_LIBS="-L$ac_python_libdir -lpython$ac_python_version"
	fi

	if test -z "PYTHON_LIBS"; then
	m4_ifvaln([$2],[$2],[
	AC_MSG_ERROR([
	Cannot determine location of your Python DSO. Please check it was installed with
	dynamic libraries enabled, or try setting PYTHON_LIBS by hand.
	])
	])
	fi
	fi
	AC_MSG_RESULT([$PYTHON_LIBS])
	AC_SUBST([PYTHON_LIBS])

	#
	# Check for site packages
	#
	AC_MSG_CHECKING([for Python site-packages path])
	if test -z "$PYTHON_SITE_PKG"; then
	PYTHON_SITE_PKG=`$PYTHON -c "import distutils.sysconfig; \
	print (distutils.sysconfig.get_python_lib(0,0));"`
	fi
	AC_MSG_RESULT([$PYTHON_SITE_PKG])
	AC_SUBST([PYTHON_SITE_PKG])

	#
	# libraries which must be linked in when embedding
	#
	AC_MSG_CHECKING(python extra libraries)
	if test -z "$PYTHON_EXTRA_LIBS"; then
	PYTHON_EXTRA_LIBS=`$PYTHON -c "import distutils.sysconfig; \
	conf = distutils.sysconfig.get_config_var; \
	print (conf('LIBS') + ' ' + conf('SYSLIBS'))"`
	fi
	AC_MSG_RESULT([$PYTHON_EXTRA_LIBS])
	AC_SUBST(PYTHON_EXTRA_LIBS)

	#
	# linking flags needed when embedding
	#
	AC_MSG_CHECKING(python extra linking flags)
	if test -z "$PYTHON_EXTRA_LDFLAGS"; then
	PYTHON_EXTRA_LDFLAGS=`$PYTHON -c "import distutils.sysconfig; \
	conf = distutils.sysconfig.get_config_var; \
	print (conf('LINKFORSHARED'))"`
	fi
	AC_MSG_RESULT([$PYTHON_EXTRA_LDFLAGS])
	AC_SUBST(PYTHON_EXTRA_LDFLAGS)

	#
	# final check to see if everything compiles alright
	#
	AC_MSG_CHECKING([consistency of all components of python development environment])
	# save current global flags
	ac_save_LIBS="$LIBS"
	ac_save_LDFLAGS="$LDFLAGS"
	ac_save_CPPFLAGS="$CPPFLAGS"
	LIBS="$ac_save_LIBS $PYTHON_LIBS $PYTHON_EXTRA_LIBS $PYTHON_EXTRA_LIBS"
	LDFLAGS="$ac_save_LDFLAGS $PYTHON_EXTRA_LDFLAGS"
	CPPFLAGS="$ac_save_CPPFLAGS $PYTHON_CPPFLAGS"
	AC_LANG_PUSH([C])
	AC_LINK_IFELSE([
	AC_LANG_PROGRAM([[#include <Python.h>]],
	[[Py_Initialize();]])
	],[pythonexists=yes],[pythonexists=no])
	AC_LANG_POP([C])
	# turn back to default flags
	CPPFLAGS="$ac_save_CPPFLAGS"
	LIBS="$ac_save_LIBS"
	LDFLAGS="$ac_save_LDFLAGS"

	AC_MSG_RESULT([$pythonexists])

	if test ! "x$pythonexists" = "xyes"; then
	m4_ifvaln([$2],[$2],[
	AC_MSG_FAILURE([
	Could not link test program to Python. Maybe the main Python library has been
	installed in some non-standard library path. If so, pass it to configure,
	via the LIBS environment variable.
	Example: ./configure LIBS="-L/usr/non-standard-path/python/lib"
	============================================================================
	ERROR!
	You probably have to install the development version of the Python package
	for your distribution. The exact name of this package varies among them.
	============================================================================
	])
	PYTHON_VERSION=""
	])
	fi

	#
	# all done!
	#
	])
	diff --git a/sys/contrib/openzfs/config/kernel-bio.m4 b/sys/contrib/openzfs/config/kernel-bio.m4
	index d8692bd39999..d088d7023cb0 100644
	--- a/sys/contrib/openzfs/config/kernel-bio.m4
	+++ b/sys/contrib/openzfs/config/kernel-bio.m4
	@@ -1,432 +1,515 @@
	dnl #
	dnl # 2.6.36 API change,
	dnl # REQ_FAILFAST_{DEV\|TRANSPORT\|DRIVER}
	dnl # REQ_DISCARD
	dnl # REQ_FLUSH
	dnl #
	dnl # 4.8 - 4.9 API,
	dnl # REQ_FLUSH was renamed to REQ_PREFLUSH
	dnl #
	AC_DEFUN([ZFS_AC_KERNEL_SRC_REQ], [
	ZFS_LINUX_TEST_SRC([req_failfast_mask], [
	#include <linux/bio.h>
	],[
	int flags __attribute__ ((unused));
	flags = REQ_FAILFAST_MASK;
	])

	ZFS_LINUX_TEST_SRC([req_discard], [
	#include <linux/bio.h>
	],[
	int flags __attribute__ ((unused));
	flags = REQ_DISCARD;
	])

	ZFS_LINUX_TEST_SRC([req_flush], [
	#include <linux/bio.h>
	],[
	int flags __attribute__ ((unused));
	flags = REQ_FLUSH;
	])

	ZFS_LINUX_TEST_SRC([req_preflush], [
	#include <linux/bio.h>
	],[
	int flags __attribute__ ((unused));
	flags = REQ_PREFLUSH;
	])
	])

	AC_DEFUN([ZFS_AC_KERNEL_BIO_REQ_FAILFAST_MASK], [
	AC_MSG_CHECKING([whether REQ_FAILFAST_MASK is defined])
	ZFS_LINUX_TEST_RESULT([req_failfast_mask], [
	AC_MSG_RESULT(yes)
	],[
	ZFS_LINUX_TEST_ERROR([REQ_FAILFAST_MASK])
	])
	])

	AC_DEFUN([ZFS_AC_KERNEL_BIO_REQ_DISCARD], [
	AC_MSG_CHECKING([whether REQ_DISCARD is defined])
	ZFS_LINUX_TEST_RESULT([req_discard], [
	AC_MSG_RESULT(yes)
	AC_DEFINE(HAVE_REQ_DISCARD, 1, [REQ_DISCARD is defined])
	],[
	AC_MSG_RESULT(no)
	])
	])

	AC_DEFUN([ZFS_AC_KERNEL_BIO_REQ_FLUSH], [
	AC_MSG_CHECKING([whether REQ_FLUSH is defined])
	ZFS_LINUX_TEST_RESULT([req_flush], [
	AC_MSG_RESULT(yes)
	AC_DEFINE(HAVE_REQ_FLUSH, 1, [REQ_FLUSH is defined])
	],[
	AC_MSG_RESULT(no)
	])
	])

	AC_DEFUN([ZFS_AC_KERNEL_BIO_REQ_PREFLUSH], [
	AC_MSG_CHECKING([whether REQ_PREFLUSH is defined])
	ZFS_LINUX_TEST_RESULT([req_preflush], [
	AC_MSG_RESULT(yes)
	AC_DEFINE(HAVE_REQ_PREFLUSH, 1, [REQ_PREFLUSH is defined])
	],[
	AC_MSG_RESULT(no)
	])
	])

	dnl #
	dnl # Linux 4.8 API,
	dnl #
	dnl # The bio_op() helper was introduced as a replacement for explicitly
	dnl # checking the bio->bi_rw flags. The following checks are used to
	dnl # detect if a specific operation is supported.
	dnl #
	AC_DEFUN([ZFS_AC_KERNEL_SRC_BIO_OPS], [
	ZFS_LINUX_TEST_SRC([req_op_discard], [
	#include <linux/blk_types.h>
	],[
	int op __attribute__ ((unused)) = REQ_OP_DISCARD;
	])

	ZFS_LINUX_TEST_SRC([req_op_secure_erase], [
	#include <linux/blk_types.h>
	],[
	int op __attribute__ ((unused)) = REQ_OP_SECURE_ERASE;
	])

	ZFS_LINUX_TEST_SRC([req_op_flush], [
	#include <linux/blk_types.h>
	],[
	int op __attribute__ ((unused)) = REQ_OP_FLUSH;
	])

	ZFS_LINUX_TEST_SRC([bio_bi_opf], [
	#include <linux/bio.h>
	],[
	struct bio bio __attribute__ ((unused));
	bio.bi_opf = 0;
	])

	ZFS_LINUX_TEST_SRC([bio_set_op_attrs], [
	#include <linux/bio.h>
	],[
	struct bio *bio __attribute__ ((unused)) = NULL;
	bio_set_op_attrs(bio, 0, 0);
	])
	])

	AC_DEFUN([ZFS_AC_KERNEL_BIO_REQ_OP_DISCARD], [
	AC_MSG_CHECKING([whether REQ_OP_DISCARD is defined])
	ZFS_LINUX_TEST_RESULT([req_op_discard], [
	AC_MSG_RESULT(yes)
	AC_DEFINE(HAVE_REQ_OP_DISCARD, 1, [REQ_OP_DISCARD is defined])
	],[
	AC_MSG_RESULT(no)
	])
	])

	AC_DEFUN([ZFS_AC_KERNEL_BIO_REQ_OP_SECURE_ERASE], [
	AC_MSG_CHECKING([whether REQ_OP_SECURE_ERASE is defined])
	ZFS_LINUX_TEST_RESULT([req_op_secure_erase], [
	AC_MSG_RESULT(yes)
	AC_DEFINE(HAVE_REQ_OP_SECURE_ERASE, 1,
	[REQ_OP_SECURE_ERASE is defined])
	],[
	AC_MSG_RESULT(no)
	])
	])

	AC_DEFUN([ZFS_AC_KERNEL_BIO_REQ_OP_FLUSH], [
	AC_MSG_CHECKING([whether REQ_OP_FLUSH is defined])
	ZFS_LINUX_TEST_RESULT([req_op_flush], [
	AC_MSG_RESULT(yes)
	AC_DEFINE(HAVE_REQ_OP_FLUSH, 1, [REQ_OP_FLUSH is defined])
	],[
	AC_MSG_RESULT(no)
	])
	])

	AC_DEFUN([ZFS_AC_KERNEL_BIO_BI_OPF], [
	AC_MSG_CHECKING([whether bio->bi_opf is defined])
	ZFS_LINUX_TEST_RESULT([bio_bi_opf], [
	AC_MSG_RESULT(yes)
	AC_DEFINE(HAVE_BIO_BI_OPF, 1, [bio->bi_opf is defined])
	],[
	AC_MSG_RESULT(no)
	])
	])

	AC_DEFUN([ZFS_AC_KERNEL_BIO_SET_OP_ATTRS], [
	AC_MSG_CHECKING([whether bio_set_op_attrs is available])
	ZFS_LINUX_TEST_RESULT([bio_set_op_attrs], [
	AC_MSG_RESULT(yes)
	AC_DEFINE(HAVE_BIO_SET_OP_ATTRS, 1,
	[bio_set_op_attrs is available])
	],[
	AC_MSG_RESULT(no)
	])
	])

	dnl #
	dnl # Linux 4.14 API,
	dnl #
	dnl # The bio_set_dev() helper macro was introduced as part of the transition
	dnl # to have struct gendisk in struct bio.
	dnl #
	dnl # Linux 5.0 API,
	dnl #
	dnl # The bio_set_dev() helper macro was updated to internally depend on
	dnl # bio_associate_blkg() symbol which is exported GPL-only.
	dnl #
	AC_DEFUN([ZFS_AC_KERNEL_SRC_BIO_SET_DEV], [
	ZFS_LINUX_TEST_SRC([bio_set_dev], [
	#include <linux/bio.h>
	#include <linux/fs.h>
	],[
	struct block_device *bdev = NULL;
	struct bio *bio = NULL;
	bio_set_dev(bio, bdev);
	], [], [ZFS_META_LICENSE])
	])

	+dnl #
	+dnl # Linux 5.16 API
	+dnl #
	+dnl # bio_set_dev is no longer a helper macro and is now an inline function,
	+dnl # meaning that the function it calls internally can no longer be overridden
	+dnl # by our code
	+dnl #
	+AC_DEFUN([ZFS_AC_KERNEL_SRC_BIO_SET_DEV_MACRO], [
	+ ZFS_LINUX_TEST_SRC([bio_set_dev_macro], [
	+ #include <linux/bio.h>
	+ #include <linux/fs.h>
	+ ],[
	+ #ifndef bio_set_dev
	+ #error Not a macro
	+ #endif
	+ ], [], [ZFS_META_LICENSE])
	+])
	+
	AC_DEFUN([ZFS_AC_KERNEL_BIO_SET_DEV], [
	AC_MSG_CHECKING([whether bio_set_dev() is available])
	ZFS_LINUX_TEST_RESULT([bio_set_dev], [
	AC_MSG_RESULT(yes)
	AC_DEFINE(HAVE_BIO_SET_DEV, 1, [bio_set_dev() is available])

	AC_MSG_CHECKING([whether bio_set_dev() is GPL-only])
	ZFS_LINUX_TEST_RESULT([bio_set_dev_license], [
	AC_MSG_RESULT(no)
	],[
	AC_MSG_RESULT(yes)
	AC_DEFINE(HAVE_BIO_SET_DEV_GPL_ONLY, 1,
	[bio_set_dev() GPL-only])
	])
	+
	+ AC_MSG_CHECKING([whether bio_set_dev() is a macro])
	+ ZFS_LINUX_TEST_RESULT([bio_set_dev_macro], [
	+ AC_MSG_RESULT(yes)
	+ AC_DEFINE(HAVE_BIO_SET_DEV_MACRO, 1,
	+ [bio_set_dev() is a macro])
	+ ],[
	+ AC_MSG_RESULT(no)
	+ ])
	],[
	AC_MSG_RESULT(no)
	])
	])

	dnl #
	dnl # 4.3 API change
	dnl # Error argument dropped from bio_endio in favor of newly introduced
	dnl # bio->bi_error. This also replaces bio->bi_flags value BIO_UPTODATE.
	dnl # Introduced by torvalds/linux@4246a0b63bd8f56a1469b12eafeb875b1041a451
	dnl # ("block: add a bi_error field to struct bio").
	dnl #
	AC_DEFUN([ZFS_AC_KERNEL_SRC_BIO_END_IO_T_ARGS], [
	ZFS_LINUX_TEST_SRC([bio_end_io_t_args], [
	#include <linux/bio.h>
	void wanted_end_io(struct bio *bio) { return; }
	bio_end_io_t *end_io __attribute__ ((unused)) = wanted_end_io;
	], [])
	])

	AC_DEFUN([ZFS_AC_KERNEL_BIO_END_IO_T_ARGS], [
	AC_MSG_CHECKING([whether bio_end_io_t wants 1 arg])
	ZFS_LINUX_TEST_RESULT([bio_end_io_t_args], [
	AC_MSG_RESULT(yes)
	AC_DEFINE(HAVE_1ARG_BIO_END_IO_T, 1,
	[bio_end_io_t wants 1 arg])
	], [
	AC_MSG_RESULT(no)
	])
	])

	dnl #
	dnl # 4.13 API change
	dnl # The bio->bi_error field was replaced with bio->bi_status which is an
	dnl # enum which describes all possible error types.
	dnl #
	AC_DEFUN([ZFS_AC_KERNEL_SRC_BIO_BI_STATUS], [
	ZFS_LINUX_TEST_SRC([bio_bi_status], [
	#include <linux/bio.h>
	], [
	struct bio bio __attribute__ ((unused));
	blk_status_t status __attribute__ ((unused)) = BLK_STS_OK;
	bio.bi_status = status;
	])
	])

	AC_DEFUN([ZFS_AC_KERNEL_BIO_BI_STATUS], [
	AC_MSG_CHECKING([whether bio->bi_status exists])
	ZFS_LINUX_TEST_RESULT([bio_bi_status], [
	AC_MSG_RESULT(yes)
	AC_DEFINE(HAVE_BIO_BI_STATUS, 1, [bio->bi_status exists])
	],[
	AC_MSG_RESULT(no)
	])
	])

	dnl #
	dnl # 3.14 API change,
	dnl # Immutable biovecs. A number of fields of struct bio are moved to
	dnl # struct bvec_iter.
	dnl #
	AC_DEFUN([ZFS_AC_KERNEL_SRC_BIO_BVEC_ITER], [
	ZFS_LINUX_TEST_SRC([bio_bvec_iter], [
	#include <linux/bio.h>
	],[
	struct bio bio;
	bio.bi_iter.bi_sector = 0;
	])
	])

	AC_DEFUN([ZFS_AC_KERNEL_BIO_BVEC_ITER], [
	AC_MSG_CHECKING([whether bio has bi_iter])
	ZFS_LINUX_TEST_RESULT([bio_bvec_iter], [
	AC_MSG_RESULT(yes)
	AC_DEFINE(HAVE_BIO_BVEC_ITER, 1, [bio has bi_iter])
	],[
	AC_MSG_RESULT(no)
	])
	])

	dnl #
	dnl # 4.8 API change
	dnl # The rw argument has been removed from submit_bio/submit_bio_wait.
	dnl # Callers are now expected to set bio->bi_rw instead of passing it in.
	dnl #
	AC_DEFUN([ZFS_AC_KERNEL_SRC_BIO_SUBMIT_BIO], [
	ZFS_LINUX_TEST_SRC([submit_bio], [
	#include <linux/bio.h>
	],[
	- blk_qc_t blk_qc;
	struct bio *bio = NULL;
	- blk_qc = submit_bio(bio);
	+ (void) submit_bio(bio);
	])
	])

	AC_DEFUN([ZFS_AC_KERNEL_BIO_SUBMIT_BIO], [
	AC_MSG_CHECKING([whether submit_bio() wants 1 arg])
	ZFS_LINUX_TEST_RESULT([submit_bio], [
	AC_MSG_RESULT(yes)
	AC_DEFINE(HAVE_1ARG_SUBMIT_BIO, 1, [submit_bio() wants 1 arg])
	],[
	AC_MSG_RESULT(no)
	])
	])

	dnl #
	dnl # 2.6.34 API change
	dnl # current->bio_list
	dnl #
	AC_DEFUN([ZFS_AC_KERNEL_SRC_BIO_CURRENT_BIO_LIST], [
	ZFS_LINUX_TEST_SRC([current_bio_list], [
	#include <linux/sched.h>
	], [
	current->bio_list = (struct bio_list *) NULL;
	])
	])

	AC_DEFUN([ZFS_AC_KERNEL_BIO_CURRENT_BIO_LIST], [
	AC_MSG_CHECKING([whether current->bio_list exists])
	ZFS_LINUX_TEST_RESULT([current_bio_list], [
	AC_MSG_RESULT(yes)
	],[
	ZFS_LINUX_TEST_ERROR([bio_list])
	])
	])

	dnl #
	dnl # Linux 5.5 API,
	dnl #
	dnl # The Linux 5.5 kernel updated percpu_ref_tryget() which is inlined by
	dnl # blkg_tryget() to use rcu_read_lock() instead of rcu_read_lock_sched().
	dnl # As a side effect the function was converted to GPL-only.
	dnl #
	AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKG_TRYGET], [
	ZFS_LINUX_TEST_SRC([blkg_tryget], [
	#include <linux/blk-cgroup.h>
	#include <linux/bio.h>
	#include <linux/fs.h>
	],[
	struct blkcg_gq blkg __attribute__ ((unused)) = {};
	bool rc __attribute__ ((unused));
	rc = blkg_tryget(&blkg);
	], [], [ZFS_META_LICENSE])
	])

	AC_DEFUN([ZFS_AC_KERNEL_BLKG_TRYGET], [
	AC_MSG_CHECKING([whether blkg_tryget() is available])
	ZFS_LINUX_TEST_RESULT([blkg_tryget], [
	AC_MSG_RESULT(yes)
	AC_DEFINE(HAVE_BLKG_TRYGET, 1, [blkg_tryget() is available])

	AC_MSG_CHECKING([whether blkg_tryget() is GPL-only])
	ZFS_LINUX_TEST_RESULT([blkg_tryget_license], [
	AC_MSG_RESULT(no)
	],[
	AC_MSG_RESULT(yes)
	AC_DEFINE(HAVE_BLKG_TRYGET_GPL_ONLY, 1,
	[blkg_tryget() GPL-only])
	])
	],[
	AC_MSG_RESULT(no)
	])
	])

	dnl #
	dnl # Linux 5.12 API,
	dnl #
	dnl # The Linux 5.12 kernel updated struct bio to create a new bi_bdev member
	dnl # and bio->bi_disk was moved to bio->bi_bdev->bd_disk
	dnl #
	AC_DEFUN([ZFS_AC_KERNEL_SRC_BIO_BDEV_DISK], [
	ZFS_LINUX_TEST_SRC([bio_bdev_disk], [
	#include <linux/blk_types.h>
	#include <linux/blkdev.h>
	],[
	struct bio *b = NULL;
	struct gendisk *d = b->bi_bdev->bd_disk;
	blk_register_queue(d);
	])
	])

	AC_DEFUN([ZFS_AC_KERNEL_BIO_BDEV_DISK], [
	AC_MSG_CHECKING([whether bio->bi_bdev->bd_disk exists])
	ZFS_LINUX_TEST_RESULT([bio_bdev_disk], [
	AC_MSG_RESULT(yes)
	AC_DEFINE(HAVE_BIO_BDEV_DISK, 1, [bio->bi_bdev->bd_disk exists])
	],[
	AC_MSG_RESULT(no)
	])
	])

	+dnl #
	+dnl # Linux 5.16 API
	+dnl #
	+dnl # The Linux 5.16 API for submit_bio changed the return type to be
	+dnl # void instead of int
	+dnl #
	+AC_DEFUN([ZFS_AC_KERNEL_SRC_BDEV_SUBMIT_BIO_RETURNS_VOID], [
	+ ZFS_LINUX_TEST_SRC([bio_bdev_submit_bio_void], [
	+ #include <linux/blkdev.h>
	+ ],[
	+ struct block_device_operations *bdev = NULL;
	+ __attribute__((unused)) void(f)(struct bio ) = bdev->submit_bio;
	+ ])
	+])
	+
	+AC_DEFUN([ZFS_AC_KERNEL_BDEV_SUBMIT_BIO_RETURNS_VOID], [
	+ AC_MSG_CHECKING(
	+ [whether block_device_operations->submit_bio() returns void])
	+ ZFS_LINUX_TEST_RESULT([bio_bdev_submit_bio_void], [
	+ AC_MSG_RESULT(yes)
	+ AC_DEFINE(HAVE_BDEV_SUBMIT_BIO_RETURNS_VOID, 1,
	+ [block_device_operations->submit_bio() returns void])
	+ ],[
	+ AC_MSG_RESULT(no)
	+ ])
	+])
	+
	+dnl #
	+dnl # Linux 5.16 API
	+dnl #
	+dnl # The Linux 5.16 API moved struct blkcg_gq into linux/blk-cgroup.h, which
	+dnl # has been around since 2015. This test looks for the presence of that
	+dnl # header, so that it can be conditionally included where it exists, but
	+dnl # still be backward compatible with kernels that pre-date its introduction.
	+dnl #
	+AC_DEFUN([ZFS_AC_KERNEL_SRC_BLK_CGROUP_HEADER], [
	+ ZFS_LINUX_TEST_SRC([blk_cgroup_header], [
	+ #include <linux/blk-cgroup.h>
	+ ], [])
	+])
	+
	+AC_DEFUN([ZFS_AC_KERNEL_BLK_CGROUP_HEADER], [
	+ AC_MSG_CHECKING([for existence of linux/blk-cgroup.h])
	+ ZFS_LINUX_TEST_RESULT([blk_cgroup_header],[
	+ AC_MSG_RESULT(yes)
	+ AC_DEFINE(HAVE_LINUX_BLK_CGROUP_HEADER, 1,
	+ [linux/blk-cgroup.h exists])
	+ ],[
	+ AC_MSG_RESULT(no)
	+ ])
	+])
	+
	AC_DEFUN([ZFS_AC_KERNEL_SRC_BIO], [
	ZFS_AC_KERNEL_SRC_REQ
	ZFS_AC_KERNEL_SRC_BIO_OPS
	ZFS_AC_KERNEL_SRC_BIO_SET_DEV
	ZFS_AC_KERNEL_SRC_BIO_END_IO_T_ARGS
	ZFS_AC_KERNEL_SRC_BIO_BI_STATUS
	ZFS_AC_KERNEL_SRC_BIO_BVEC_ITER
	ZFS_AC_KERNEL_SRC_BIO_SUBMIT_BIO
	ZFS_AC_KERNEL_SRC_BIO_CURRENT_BIO_LIST
	ZFS_AC_KERNEL_SRC_BLKG_TRYGET
	ZFS_AC_KERNEL_SRC_BIO_BDEV_DISK
	+ ZFS_AC_KERNEL_SRC_BDEV_SUBMIT_BIO_RETURNS_VOID
	+ ZFS_AC_KERNEL_SRC_BIO_SET_DEV_MACRO
	+ ZFS_AC_KERNEL_SRC_BLK_CGROUP_HEADER
	])

	AC_DEFUN([ZFS_AC_KERNEL_BIO], [
	ZFS_AC_KERNEL_BIO_REQ_FAILFAST_MASK
	ZFS_AC_KERNEL_BIO_REQ_DISCARD
	ZFS_AC_KERNEL_BIO_REQ_FLUSH
	ZFS_AC_KERNEL_BIO_REQ_PREFLUSH

	ZFS_AC_KERNEL_BIO_REQ_OP_DISCARD
	ZFS_AC_KERNEL_BIO_REQ_OP_SECURE_ERASE
	ZFS_AC_KERNEL_BIO_REQ_OP_FLUSH
	ZFS_AC_KERNEL_BIO_BI_OPF
	ZFS_AC_KERNEL_BIO_SET_OP_ATTRS

	ZFS_AC_KERNEL_BIO_SET_DEV
	ZFS_AC_KERNEL_BIO_END_IO_T_ARGS
	ZFS_AC_KERNEL_BIO_BI_STATUS
	ZFS_AC_KERNEL_BIO_BVEC_ITER
	ZFS_AC_KERNEL_BIO_SUBMIT_BIO
	ZFS_AC_KERNEL_BIO_CURRENT_BIO_LIST
	ZFS_AC_KERNEL_BLKG_TRYGET
	ZFS_AC_KERNEL_BIO_BDEV_DISK
	+ ZFS_AC_KERNEL_BDEV_SUBMIT_BIO_RETURNS_VOID
	+ ZFS_AC_KERNEL_BLK_CGROUP_HEADER
	])
	diff --git a/sys/contrib/openzfs/config/kernel-blkdev.m4 b/sys/contrib/openzfs/config/kernel-blkdev.m4
	index 61e66421f8ec..9c60e5dd4210 100644
	--- a/sys/contrib/openzfs/config/kernel-blkdev.m4
	+++ b/sys/contrib/openzfs/config/kernel-blkdev.m4
	@@ -1,321 +1,343 @@
	dnl #
	dnl # 2.6.38 API change,
	dnl # Added blkdev_get_by_path()
	dnl #
	AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV_GET_BY_PATH], [
	ZFS_LINUX_TEST_SRC([blkdev_get_by_path], [
	#include <linux/fs.h>
	#include <linux/blkdev.h>
	], [
	struct block_device *bdev __attribute__ ((unused)) = NULL;
	const char *path = "path";
	fmode_t mode = 0;
	void *holder = NULL;

	bdev = blkdev_get_by_path(path, mode, holder);
	])
	])

	AC_DEFUN([ZFS_AC_KERNEL_BLKDEV_GET_BY_PATH], [
	AC_MSG_CHECKING([whether blkdev_get_by_path() exists])
	ZFS_LINUX_TEST_RESULT([blkdev_get_by_path], [
	AC_MSG_RESULT(yes)
	], [
	ZFS_LINUX_TEST_ERROR([blkdev_get_by_path()])
	])
	])

	dnl #
	dnl # 2.6.38 API change,
	dnl # Added blkdev_put()
	dnl #
	AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV_PUT], [
	ZFS_LINUX_TEST_SRC([blkdev_put], [
	#include <linux/fs.h>
	#include <linux/blkdev.h>
	], [
	struct block_device *bdev = NULL;
	fmode_t mode = 0;

	blkdev_put(bdev, mode);
	])
	])

	AC_DEFUN([ZFS_AC_KERNEL_BLKDEV_PUT], [
	AC_MSG_CHECKING([whether blkdev_put() exists])
	ZFS_LINUX_TEST_RESULT([blkdev_put], [
	AC_MSG_RESULT(yes)
	], [
	ZFS_LINUX_TEST_ERROR([blkdev_put()])
	])
	])

	dnl #
	dnl # 4.1 API, exported blkdev_reread_part() symbol, back ported to the
	dnl # 3.10.0 CentOS 7.x enterprise kernels.
	dnl #
	AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV_REREAD_PART], [
	ZFS_LINUX_TEST_SRC([blkdev_reread_part], [
	#include <linux/fs.h>
	#include <linux/blkdev.h>
	], [
	struct block_device *bdev = NULL;
	int error;

	error = blkdev_reread_part(bdev);
	])
	])

	AC_DEFUN([ZFS_AC_KERNEL_BLKDEV_REREAD_PART], [
	AC_MSG_CHECKING([whether blkdev_reread_part() exists])
	ZFS_LINUX_TEST_RESULT([blkdev_reread_part], [
	AC_MSG_RESULT(yes)
	AC_DEFINE(HAVE_BLKDEV_REREAD_PART, 1,
	[blkdev_reread_part() exists])
	], [
	AC_MSG_RESULT(no)
	])
	])

	dnl #
	dnl # check_disk_change() was removed in 5.10
	dnl #
	AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV_CHECK_DISK_CHANGE], [
	ZFS_LINUX_TEST_SRC([check_disk_change], [
	#include <linux/fs.h>
	#include <linux/blkdev.h>
	], [
	struct block_device *bdev = NULL;
	bool error;

	error = check_disk_change(bdev);
	])
	])

	AC_DEFUN([ZFS_AC_KERNEL_BLKDEV_CHECK_DISK_CHANGE], [
	AC_MSG_CHECKING([whether check_disk_change() exists])
	ZFS_LINUX_TEST_RESULT([check_disk_change], [
	AC_MSG_RESULT(yes)
	AC_DEFINE(HAVE_CHECK_DISK_CHANGE, 1,
	[check_disk_change() exists])
	], [
	AC_MSG_RESULT(no)
	])
	])

	dnl #
	dnl # 5.10 API, check_disk_change() is removed, in favor of
	dnl # bdev_check_media_change(), which doesn't force revalidation
	dnl #
	AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV_BDEV_CHECK_MEDIA_CHANGE], [
	ZFS_LINUX_TEST_SRC([bdev_check_media_change], [
	#include <linux/fs.h>
	#include <linux/blkdev.h>
	], [
	struct block_device *bdev = NULL;
	int error;

	error = bdev_check_media_change(bdev);
	])
	])

	AC_DEFUN([ZFS_AC_KERNEL_BLKDEV_BDEV_CHECK_MEDIA_CHANGE], [
	AC_MSG_CHECKING([whether bdev_check_media_change() exists])
	ZFS_LINUX_TEST_RESULT([bdev_check_media_change], [
	AC_MSG_RESULT(yes)
	AC_DEFINE(HAVE_BDEV_CHECK_MEDIA_CHANGE, 1,
	[bdev_check_media_change() exists])
	], [
	AC_MSG_RESULT(no)
	])
	])

	dnl #
	dnl # 2.6.22 API change
	dnl # Single argument invalidate_bdev()
	dnl #
	AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV_INVALIDATE_BDEV], [
	ZFS_LINUX_TEST_SRC([invalidate_bdev], [
	#include <linux/buffer_head.h>
	#include <linux/blkdev.h>
	],[
	struct block_device *bdev = NULL;
	invalidate_bdev(bdev);
	])
	])

	AC_DEFUN([ZFS_AC_KERNEL_BLKDEV_INVALIDATE_BDEV], [
	AC_MSG_CHECKING([whether invalidate_bdev() exists])
	ZFS_LINUX_TEST_RESULT([invalidate_bdev], [
	AC_MSG_RESULT(yes)
	],[
	ZFS_LINUX_TEST_ERROR([invalidate_bdev()])
	])
	])

	dnl #
	dnl # 5.11 API, lookup_bdev() takes dev_t argument.
	dnl # 2.6.27 API, lookup_bdev() was first exported.
	dnl # 4.4.0-6.21 API, lookup_bdev() on Ubuntu takes mode argument.
	dnl #
	AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV_LOOKUP_BDEV], [
	ZFS_LINUX_TEST_SRC([lookup_bdev_devt], [
	#include <linux/blkdev.h>
	], [
	int error __attribute__ ((unused));
	const char path[] = "/example/path";
	dev_t dev;

	error = lookup_bdev(path, &dev);
	])

	ZFS_LINUX_TEST_SRC([lookup_bdev_1arg], [
	#include <linux/fs.h>
	#include <linux/blkdev.h>
	], [
	struct block_device *bdev __attribute__ ((unused));
	const char path[] = "/example/path";

	bdev = lookup_bdev(path);
	])

	ZFS_LINUX_TEST_SRC([lookup_bdev_mode], [
	#include <linux/fs.h>
	], [
	struct block_device *bdev __attribute__ ((unused));
	const char path[] = "/example/path";

	bdev = lookup_bdev(path, FMODE_READ);
	])
	])

	AC_DEFUN([ZFS_AC_KERNEL_BLKDEV_LOOKUP_BDEV], [
	AC_MSG_CHECKING([whether lookup_bdev() wants dev_t arg])
	ZFS_LINUX_TEST_RESULT_SYMBOL([lookup_bdev_devt],
	[lookup_bdev], [fs/block_dev.c], [
	AC_MSG_RESULT(yes)
	AC_DEFINE(HAVE_DEVT_LOOKUP_BDEV, 1,
	[lookup_bdev() wants dev_t arg])
	], [
	AC_MSG_RESULT(no)

	AC_MSG_CHECKING([whether lookup_bdev() wants 1 arg])
	ZFS_LINUX_TEST_RESULT_SYMBOL([lookup_bdev_1arg],
	[lookup_bdev], [fs/block_dev.c], [
	AC_MSG_RESULT(yes)
	AC_DEFINE(HAVE_1ARG_LOOKUP_BDEV, 1,
	[lookup_bdev() wants 1 arg])
	], [
	AC_MSG_RESULT(no)

	AC_MSG_CHECKING([whether lookup_bdev() wants mode arg])
	ZFS_LINUX_TEST_RESULT_SYMBOL([lookup_bdev_mode],
	[lookup_bdev], [fs/block_dev.c], [
	AC_MSG_RESULT(yes)
	AC_DEFINE(HAVE_MODE_LOOKUP_BDEV, 1,
	[lookup_bdev() wants mode arg])
	], [
	ZFS_LINUX_TEST_ERROR([lookup_bdev()])
	])
	])
	])
	])

	dnl #
	dnl # 2.6.30 API change
	dnl #
	dnl # The bdev_physical_block_size() interface was added to provide a way
	dnl # to determine the smallest write which can be performed without a
	dnl # read-modify-write operation.
	dnl #
	dnl # Unfortunately, this interface isn't entirely reliable because
	dnl # drives are sometimes known to misreport this value.
	dnl #
	AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV_BDEV_PHYSICAL_BLOCK_SIZE], [
	ZFS_LINUX_TEST_SRC([bdev_physical_block_size], [
	#include <linux/blkdev.h>
	],[
	struct block_device *bdev __attribute__ ((unused)) = NULL;
	bdev_physical_block_size(bdev);
	])
	])

	AC_DEFUN([ZFS_AC_KERNEL_BLKDEV_BDEV_PHYSICAL_BLOCK_SIZE], [
	AC_MSG_CHECKING([whether bdev_physical_block_size() is available])
	ZFS_LINUX_TEST_RESULT([bdev_physical_block_size], [
	AC_MSG_RESULT(yes)
	],[
	ZFS_LINUX_TEST_ERROR([bdev_physical_block_size()])
	])
	])

	dnl #
	dnl # 2.6.30 API change
	dnl # Added bdev_logical_block_size().
	dnl #
	AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV_BDEV_LOGICAL_BLOCK_SIZE], [
	ZFS_LINUX_TEST_SRC([bdev_logical_block_size], [
	#include <linux/blkdev.h>
	],[
	struct block_device *bdev __attribute__ ((unused)) = NULL;
	bdev_logical_block_size(bdev);
	])
	])

	AC_DEFUN([ZFS_AC_KERNEL_BLKDEV_BDEV_LOGICAL_BLOCK_SIZE], [
	AC_MSG_CHECKING([whether bdev_logical_block_size() is available])
	ZFS_LINUX_TEST_RESULT([bdev_logical_block_size], [
	AC_MSG_RESULT(yes)
	],[
	ZFS_LINUX_TEST_ERROR([bdev_logical_block_size()])
	])
	])

	dnl #
	dnl # 5.11 API change
	dnl # Added bdev_whole() helper.
	dnl #
	AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV_BDEV_WHOLE], [
	ZFS_LINUX_TEST_SRC([bdev_whole], [
	#include <linux/blkdev.h>
	],[
	struct block_device *bdev = NULL;
	bdev = bdev_whole(bdev);
	])
	])

	AC_DEFUN([ZFS_AC_KERNEL_BLKDEV_BDEV_WHOLE], [
	AC_MSG_CHECKING([whether bdev_whole() is available])
	ZFS_LINUX_TEST_RESULT([bdev_whole], [
	AC_MSG_RESULT(yes)
	AC_DEFINE(HAVE_BDEV_WHOLE, 1, [bdev_whole() is available])
	],[
	AC_MSG_RESULT(no)
	])
	])

	+dnl #
	+dnl # 5.13 API change
	+dnl # blkdev_get_by_path() no longer handles ERESTARTSYS
	+dnl #
	+dnl # Unfortunately we're forced to rely solely on the kernel version
	+dnl # number in order to determine the expected behavior. This was an
	+dnl # internal change to blkdev_get_by_dev(), see commit a8ed1a0607.
	+dnl #
	+AC_DEFUN([ZFS_AC_KERNEL_BLKDEV_GET_ERESTARTSYS], [
	+ AC_MSG_CHECKING([whether blkdev_get_by_path() handles ERESTARTSYS])
	+ AS_VERSION_COMPARE([$LINUX_VERSION], [5.13.0], [
	+ AC_MSG_RESULT(yes)
	+ AC_DEFINE(HAVE_BLKDEV_GET_ERESTARTSYS, 1,
	+ [blkdev_get_by_path() handles ERESTARTSYS])
	+ ],[
	+ AC_MSG_RESULT(no)
	+ ],[
	+ AC_MSG_RESULT(no)
	+ ])
	+])
	+
	AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV], [
	ZFS_AC_KERNEL_SRC_BLKDEV_GET_BY_PATH
	ZFS_AC_KERNEL_SRC_BLKDEV_PUT
	ZFS_AC_KERNEL_SRC_BLKDEV_REREAD_PART
	ZFS_AC_KERNEL_SRC_BLKDEV_INVALIDATE_BDEV
	ZFS_AC_KERNEL_SRC_BLKDEV_LOOKUP_BDEV
	ZFS_AC_KERNEL_SRC_BLKDEV_BDEV_LOGICAL_BLOCK_SIZE
	ZFS_AC_KERNEL_SRC_BLKDEV_BDEV_PHYSICAL_BLOCK_SIZE
	ZFS_AC_KERNEL_SRC_BLKDEV_CHECK_DISK_CHANGE
	ZFS_AC_KERNEL_SRC_BLKDEV_BDEV_CHECK_MEDIA_CHANGE
	ZFS_AC_KERNEL_SRC_BLKDEV_BDEV_WHOLE
	])

	AC_DEFUN([ZFS_AC_KERNEL_BLKDEV], [
	ZFS_AC_KERNEL_BLKDEV_GET_BY_PATH
	ZFS_AC_KERNEL_BLKDEV_PUT
	ZFS_AC_KERNEL_BLKDEV_REREAD_PART
	ZFS_AC_KERNEL_BLKDEV_INVALIDATE_BDEV
	ZFS_AC_KERNEL_BLKDEV_LOOKUP_BDEV
	ZFS_AC_KERNEL_BLKDEV_BDEV_LOGICAL_BLOCK_SIZE
	ZFS_AC_KERNEL_BLKDEV_BDEV_PHYSICAL_BLOCK_SIZE
	ZFS_AC_KERNEL_BLKDEV_CHECK_DISK_CHANGE
	ZFS_AC_KERNEL_BLKDEV_BDEV_CHECK_MEDIA_CHANGE
	ZFS_AC_KERNEL_BLKDEV_BDEV_WHOLE
	+ ZFS_AC_KERNEL_BLKDEV_GET_ERESTARTSYS
	])
	diff --git a/sys/contrib/openzfs/config/kernel-config-defined.m4 b/sys/contrib/openzfs/config/kernel-config-defined.m4
	index 9b9468269ca3..c7d18b49b14e 100644
	--- a/sys/contrib/openzfs/config/kernel-config-defined.m4
	+++ b/sys/contrib/openzfs/config/kernel-config-defined.m4
	@@ -1,183 +1,152 @@
	dnl #
	dnl # Certain kernel build options are not supported. These must be
	dnl # detected at configure time and cause a build failure. Otherwise
	dnl # modules may be successfully built that behave incorrectly.
	dnl #
	AC_DEFUN([ZFS_AC_KERNEL_CONFIG_DEFINED], [
	AS_IF([test "x$cross_compiling" != xyes], [
	AC_RUN_IFELSE([
	AC_LANG_PROGRAM([
	#include "$LINUX/include/linux/license.h"
	], [
	return !license_is_gpl_compatible(
	"$ZFS_META_LICENSE");
	])
	], [
	AC_DEFINE([ZFS_IS_GPL_COMPATIBLE], [1],
	[Define to 1 if GPL-only symbols can be used])
	], [
	])
	])

	- ZFS_AC_KERNEL_SRC_CONFIG_THREAD_SIZE
	ZFS_AC_KERNEL_SRC_CONFIG_DEBUG_LOCK_ALLOC
	ZFS_AC_KERNEL_SRC_CONFIG_TRIM_UNUSED_KSYMS
	ZFS_AC_KERNEL_SRC_CONFIG_ZLIB_INFLATE
	ZFS_AC_KERNEL_SRC_CONFIG_ZLIB_DEFLATE

	AC_MSG_CHECKING([for kernel config option compatibility])
	ZFS_LINUX_TEST_COMPILE_ALL([config])
	AC_MSG_RESULT([done])

	- ZFS_AC_KERNEL_CONFIG_THREAD_SIZE
	ZFS_AC_KERNEL_CONFIG_DEBUG_LOCK_ALLOC
	ZFS_AC_KERNEL_CONFIG_TRIM_UNUSED_KSYMS
	ZFS_AC_KERNEL_CONFIG_ZLIB_INFLATE
	ZFS_AC_KERNEL_CONFIG_ZLIB_DEFLATE
	])

	-dnl #
	-dnl # Check configured THREAD_SIZE
	-dnl #
	-dnl # The stack size will vary by architecture, but as of Linux 3.15 on x86_64
	-dnl # the default thread stack size was increased to 16K from 8K. Therefore,
	-dnl # on newer kernels and some architectures stack usage optimizations can be
	-dnl # conditionally applied to improve performance without negatively impacting
	-dnl # stability.
	-dnl #
	-AC_DEFUN([ZFS_AC_KERNEL_SRC_CONFIG_THREAD_SIZE], [
	- ZFS_LINUX_TEST_SRC([config_thread_size], [
	- #include <linux/module.h>
	- ],[
	- #if (THREAD_SIZE < 16384)
	- #error "THREAD_SIZE is less than 16K"
	- #endif
	- ])
	-])
	-
	-AC_DEFUN([ZFS_AC_KERNEL_CONFIG_THREAD_SIZE], [
	- AC_MSG_CHECKING([whether kernel was built with 16K or larger stacks])
	- ZFS_LINUX_TEST_RESULT([config_thread_size], [
	- AC_MSG_RESULT([yes])
	- AC_DEFINE(HAVE_LARGE_STACKS, 1, [kernel has large stacks])
	- ],[
	- AC_MSG_RESULT([no])
	- ])
	-])
	-
	dnl #
	dnl # Check CONFIG_DEBUG_LOCK_ALLOC
	dnl #
	dnl # This is typically only set for debug kernels because it comes with
	dnl # a performance penalty. However, when it is set it maps the non-GPL
	dnl # symbol mutex_lock() to the GPL-only mutex_lock_nested() symbol.
	dnl # This will cause a failure at link time which we'd rather know about
	dnl # at compile time.
	dnl #
	dnl # Since we plan to pursue making mutex_lock_nested() a non-GPL symbol
	dnl # with the upstream community we add a check to detect this case.
	dnl #
	AC_DEFUN([ZFS_AC_KERNEL_SRC_CONFIG_DEBUG_LOCK_ALLOC], [
	ZFS_LINUX_TEST_SRC([config_debug_lock_alloc], [
	#include <linux/mutex.h>
	],[
	struct mutex lock;

	mutex_init(&lock);
	mutex_lock(&lock);
	mutex_unlock(&lock);
	], [], [ZFS_META_LICENSE])
	])

	AC_DEFUN([ZFS_AC_KERNEL_CONFIG_DEBUG_LOCK_ALLOC], [
	AC_MSG_CHECKING([whether mutex_lock() is GPL-only])
	ZFS_LINUX_TEST_RESULT([config_debug_lock_alloc_license], [
	AC_MSG_RESULT(no)
	],[
	AC_MSG_RESULT(yes)
	AC_MSG_ERROR([
	*** Kernel built with CONFIG_DEBUG_LOCK_ALLOC which is incompatible
	*** with the CDDL license and will prevent the module linking stage
	*** from succeeding. You must rebuild your kernel without this
	*** option enabled.])
	])
	])

	dnl #
	dnl # Check CONFIG_TRIM_UNUSED_KSYMS
	dnl #
	dnl # Verify the kernel has CONFIG_TRIM_UNUSED_KSYMS disabled.
	dnl #
	AC_DEFUN([ZFS_AC_KERNEL_SRC_CONFIG_TRIM_UNUSED_KSYMS], [
	ZFS_LINUX_TEST_SRC([config_trim_unusued_ksyms], [
	#if defined(CONFIG_TRIM_UNUSED_KSYMS)
	#error CONFIG_TRIM_UNUSED_KSYMS not defined
	#endif
	],[])
	])

	AC_DEFUN([ZFS_AC_KERNEL_CONFIG_TRIM_UNUSED_KSYMS], [
	AC_MSG_CHECKING([whether CONFIG_TRIM_UNUSED_KSYM is disabled])
	ZFS_LINUX_TEST_RESULT([config_trim_unusued_ksyms], [
	AC_MSG_RESULT([yes])
	],[
	AC_MSG_RESULT([no])
	AS_IF([test "x$enable_linux_builtin" != xyes], [
	AC_MSG_ERROR([
	*** This kernel has unused symbols trimming enabled, please disable.
	*** Rebuild the kernel with CONFIG_TRIM_UNUSED_KSYMS=n set.])
	])
	])
	])

	dnl #
	dnl # Check CONFIG_ZLIB_INFLATE
	dnl #
	dnl # Verify the kernel has CONFIG_ZLIB_INFLATE support enabled.
	dnl #
	AC_DEFUN([ZFS_AC_KERNEL_SRC_CONFIG_ZLIB_INFLATE], [
	ZFS_LINUX_TEST_SRC([config_zlib_inflate], [
	#if !defined(CONFIG_ZLIB_INFLATE) && \
	!defined(CONFIG_ZLIB_INFLATE_MODULE)
	#error CONFIG_ZLIB_INFLATE not defined
	#endif
	],[])
	])

	AC_DEFUN([ZFS_AC_KERNEL_CONFIG_ZLIB_INFLATE], [
	AC_MSG_CHECKING([whether CONFIG_ZLIB_INFLATE is defined])
	ZFS_LINUX_TEST_RESULT([config_zlib_inflate], [
	AC_MSG_RESULT([yes])
	],[
	AC_MSG_RESULT([no])
	AC_MSG_ERROR([
	*** This kernel does not include the required zlib inflate support.
	*** Rebuild the kernel with CONFIG_ZLIB_INFLATE=y\|m set.])
	])
	])

	dnl #
	dnl # Check CONFIG_ZLIB_DEFLATE
	dnl #
	dnl # Verify the kernel has CONFIG_ZLIB_DEFLATE support enabled.
	dnl #
	AC_DEFUN([ZFS_AC_KERNEL_SRC_CONFIG_ZLIB_DEFLATE], [
	ZFS_LINUX_TEST_SRC([config_zlib_deflate], [
	#if !defined(CONFIG_ZLIB_DEFLATE) && \
	!defined(CONFIG_ZLIB_DEFLATE_MODULE)
	#error CONFIG_ZLIB_DEFLATE not defined
	#endif
	],[])
	])

	AC_DEFUN([ZFS_AC_KERNEL_CONFIG_ZLIB_DEFLATE], [
	AC_MSG_CHECKING([whether CONFIG_ZLIB_DEFLATE is defined])
	ZFS_LINUX_TEST_RESULT([config_zlib_deflate], [
	AC_MSG_RESULT([yes])
	],[
	AC_MSG_RESULT([no])
	AC_MSG_ERROR([
	*** This kernel does not include the required zlib deflate support.
	*** Rebuild the kernel with CONFIG_ZLIB_DEFLATE=y\|m set.])
	])
	])
	diff --git a/sys/contrib/openzfs/config/kernel-fpu.m4 b/sys/contrib/openzfs/config/kernel-fpu.m4
	index 4d6fe052289c..faa64f1ec46b 100644
	--- a/sys/contrib/openzfs/config/kernel-fpu.m4
	+++ b/sys/contrib/openzfs/config/kernel-fpu.m4
	@@ -1,131 +1,146 @@
	dnl #
	dnl # Handle differences in kernel FPU code.
	dnl #
	dnl # Kernel
	+dnl # 5.16: XCR code put into asm/fpu/xcr.h
	+dnl # HAVE_KERNEL_FPU_XCR_HEADER
	+dnl #
	dnl # 5.0: Wrappers have been introduced to save/restore the FPU state.
	dnl # This change was made to the 4.19.38 and 4.14.120 LTS kernels.
	dnl # HAVE_KERNEL_FPU_INTERNAL
	dnl #
	dnl # 4.2: Use __kernel_fpu_{begin,end}()
	dnl # HAVE_UNDERSCORE_KERNEL_FPU & KERNEL_EXPORTS_X86_FPU
	dnl #
	dnl # Pre-4.2: Use kernel_fpu_{begin,end}()
	dnl # HAVE_KERNEL_FPU & KERNEL_EXPORTS_X86_FPU
	dnl #
	dnl # N.B. The header check is performed before all other checks since it
	dnl # depends on HAVE_KERNEL_FPU_API_HEADER being set in confdefs.h.
	dnl #
	AC_DEFUN([ZFS_AC_KERNEL_FPU_HEADER], [
	AC_MSG_CHECKING([whether fpu headers are available])
	ZFS_LINUX_TRY_COMPILE([
	#include <linux/module.h>
	#include <asm/fpu/api.h>
	],[
	],[
	AC_DEFINE(HAVE_KERNEL_FPU_API_HEADER, 1,
	[kernel has asm/fpu/api.h])
	AC_MSG_RESULT(asm/fpu/api.h)
	+ AC_MSG_CHECKING([whether fpu/xcr header is available])
	+ ZFS_LINUX_TRY_COMPILE([
	+ #include <linux/module.h>
	+ #include <asm/fpu/xcr.h>
	+ ],[
	+ ],[
	+ AC_DEFINE(HAVE_KERNEL_FPU_XCR_HEADER, 1,
	+ [kernel has asm/fpu/xcr.h])
	+ AC_MSG_RESULT(asm/fpu/xcr.h)
	+ ],[
	+ AC_MSG_RESULT(no asm/fpu/xcr.h)
	+ ])
	],[
	AC_MSG_RESULT(i387.h & xcr.h)
	])
	])

	AC_DEFUN([ZFS_AC_KERNEL_SRC_FPU], [
	ZFS_LINUX_TEST_SRC([kernel_fpu], [
	#include <linux/types.h>
	#ifdef HAVE_KERNEL_FPU_API_HEADER
	#include <asm/fpu/api.h>
	#else
	#include <asm/i387.h>
	#include <asm/xcr.h>
	#endif
	], [
	kernel_fpu_begin();
	kernel_fpu_end();
	], [], [ZFS_META_LICENSE])

	ZFS_LINUX_TEST_SRC([__kernel_fpu], [
	#include <linux/types.h>
	#ifdef HAVE_KERNEL_FPU_API_HEADER
	#include <asm/fpu/api.h>
	#else
	#include <asm/i387.h>
	#include <asm/xcr.h>
	#endif
	], [
	__kernel_fpu_begin();
	__kernel_fpu_end();
	], [], [ZFS_META_LICENSE])

	ZFS_LINUX_TEST_SRC([fpu_internal], [
	#if defined(__x86_64) \|\| defined(__x86_64__) \|\| \
	defined(__i386) \|\| defined(__i386__)
	#if !defined(__x86)
	#define __x86
	#endif
	#endif

	#if !defined(__x86)
	#error Unsupported architecture
	#endif

	#include <linux/types.h>
	#ifdef HAVE_KERNEL_FPU_API_HEADER
	#include <asm/fpu/api.h>
	#include <asm/fpu/internal.h>
	#else
	#include <asm/i387.h>
	#include <asm/xcr.h>
	#endif

	#if !defined(XSTATE_XSAVE)
	#error XSTATE_XSAVE not defined
	#endif

	#if !defined(XSTATE_XRESTORE)
	#error XSTATE_XRESTORE not defined
	#endif
	],[
	struct fpu *fpu = &current->thread.fpu;
	union fpregs_state *st = &fpu->state;
	struct fregs_state *fr __attribute__ ((unused)) = &st->fsave;
	struct fxregs_state *fxr __attribute__ ((unused)) = &st->fxsave;
	struct xregs_state *xr __attribute__ ((unused)) = &st->xsave;
	])
	])

	AC_DEFUN([ZFS_AC_KERNEL_FPU], [
	dnl #
	dnl # Legacy kernel
	dnl #
	AC_MSG_CHECKING([whether kernel fpu is available])
	ZFS_LINUX_TEST_RESULT_SYMBOL([kernel_fpu_license],
	[kernel_fpu_begin], [arch/x86/kernel/fpu/core.c], [
	AC_MSG_RESULT(kernel_fpu_*)
	AC_DEFINE(HAVE_KERNEL_FPU, 1,
	[kernel has kernel_fpu_* functions])
	AC_DEFINE(KERNEL_EXPORTS_X86_FPU, 1,
	[kernel exports FPU functions])
	],[
	dnl #
	dnl # Linux 4.2 kernel
	dnl #
	ZFS_LINUX_TEST_RESULT_SYMBOL([__kernel_fpu_license],
	[__kernel_fpu_begin],
	[arch/x86/kernel/fpu/core.c arch/x86/kernel/i387.c], [
	AC_MSG_RESULT(__kernel_fpu_*)
	AC_DEFINE(HAVE_UNDERSCORE_KERNEL_FPU, 1,
	[kernel has __kernel_fpu_* functions])
	AC_DEFINE(KERNEL_EXPORTS_X86_FPU, 1,
	[kernel exports FPU functions])
	],[
	ZFS_LINUX_TEST_RESULT([fpu_internal], [
	AC_MSG_RESULT(internal)
	AC_DEFINE(HAVE_KERNEL_FPU_INTERNAL, 1,
	[kernel fpu internal])
	],[
	AC_MSG_RESULT(unavailable)
	])
	])
	])
	])
	diff --git a/sys/contrib/openzfs/config/kernel-pagemap-folio_wait_bit.m4 b/sys/contrib/openzfs/config/kernel-pagemap-folio_wait_bit.m4
	new file mode 100644
	index 000000000000..e0aaa4a57411
	--- /dev/null
	+++ b/sys/contrib/openzfs/config/kernel-pagemap-folio_wait_bit.m4
	@@ -0,0 +1,26 @@
	+dnl #
	+dnl # Linux 5.16 no longer allows directly calling wait_on_page_bit, and
	+dnl # instead requires you to call folio-specific functions. In this case,
	+dnl # wait_on_page_bit(pg, PG_writeback) becomes
	+dnl # folio_wait_bit(pg, PG_writeback)
	+dnl #
	+AC_DEFUN([ZFS_AC_KERNEL_SRC_PAGEMAP_FOLIO_WAIT_BIT], [
	+ ZFS_LINUX_TEST_SRC([pagemap_has_folio_wait_bit], [
	+ #include <linux/pagemap.h>
	+ ],[
	+ static struct folio *f = NULL;
	+
	+ folio_wait_bit(f, PG_writeback);
	+ ])
	+])
	+
	+AC_DEFUN([ZFS_AC_KERNEL_PAGEMAP_FOLIO_WAIT_BIT], [
	+ AC_MSG_CHECKING([folio_wait_bit() exists])
	+ ZFS_LINUX_TEST_RESULT([pagemap_has_folio_wait_bit], [
	+ AC_MSG_RESULT([yes])
	+ AC_DEFINE(HAVE_PAGEMAP_FOLIO_WAIT_BIT, 1,
	+ [folio_wait_bit() exists])
	+ ],[
	+ AC_MSG_RESULT([no])
	+ ])
	+])
	diff --git a/sys/contrib/openzfs/config/kernel-vfs-iov_iter.m4 b/sys/contrib/openzfs/config/kernel-vfs-iov_iter.m4
	index bee6d0be9666..ecdda939f1cf 100644
	--- a/sys/contrib/openzfs/config/kernel-vfs-iov_iter.m4
	+++ b/sys/contrib/openzfs/config/kernel-vfs-iov_iter.m4
	@@ -1,162 +1,184 @@
	dnl #
	dnl # Check for available iov_iter functionality.
	dnl #
	AC_DEFUN([ZFS_AC_KERNEL_SRC_VFS_IOV_ITER], [
	ZFS_LINUX_TEST_SRC([iov_iter_types], [
	#include <linux/fs.h>
	#include <linux/uio.h>
	],[
	int type __attribute__ ((unused)) =
	ITER_IOVEC \| ITER_KVEC \| ITER_BVEC \| ITER_PIPE;
	])

	ZFS_LINUX_TEST_SRC([iov_iter_advance], [
	#include <linux/fs.h>
	#include <linux/uio.h>
	],[
	struct iov_iter iter = { 0 };
	size_t advance = 512;

	iov_iter_advance(&iter, advance);
	])

	ZFS_LINUX_TEST_SRC([iov_iter_revert], [
	#include <linux/fs.h>
	#include <linux/uio.h>
	],[
	struct iov_iter iter = { 0 };
	size_t revert = 512;

	iov_iter_revert(&iter, revert);
	])

	ZFS_LINUX_TEST_SRC([iov_iter_fault_in_readable], [
	#include <linux/fs.h>
	#include <linux/uio.h>
	],[
	struct iov_iter iter = { 0 };
	size_t size = 512;
	int error __attribute__ ((unused));

	error = iov_iter_fault_in_readable(&iter, size);
	])

	ZFS_LINUX_TEST_SRC([iov_iter_count], [
	#include <linux/fs.h>
	#include <linux/uio.h>
	],[
	struct iov_iter iter = { 0 };
	size_t bytes __attribute__ ((unused));

	bytes = iov_iter_count(&iter);
	])

	ZFS_LINUX_TEST_SRC([copy_to_iter], [
	#include <linux/fs.h>
	#include <linux/uio.h>
	],[
	struct iov_iter iter = { 0 };
	char buf[512] = { 0 };
	size_t size = 512;
	size_t bytes __attribute__ ((unused));

	bytes = copy_to_iter((const void *)&buf, size, &iter);
	])

	ZFS_LINUX_TEST_SRC([copy_from_iter], [
	#include <linux/fs.h>
	#include <linux/uio.h>
	],[
	struct iov_iter iter = { 0 };
	char buf[512] = { 0 };
	size_t size = 512;
	size_t bytes __attribute__ ((unused));

	bytes = copy_from_iter((void *)&buf, size, &iter);
	])
	+
	+ ZFS_LINUX_TEST_SRC([iov_iter_type], [
	+ #include <linux/fs.h>
	+ #include <linux/uio.h>
	+ ],[
	+ struct iov_iter iter = { 0 };
	+ __attribute__((unused)) enum iter_type i = iov_iter_type(&iter);
	+ ])
	])

	AC_DEFUN([ZFS_AC_KERNEL_VFS_IOV_ITER], [
	enable_vfs_iov_iter="yes"

	AC_MSG_CHECKING([whether iov_iter types are available])
	ZFS_LINUX_TEST_RESULT([iov_iter_types], [
	AC_MSG_RESULT(yes)
	AC_DEFINE(HAVE_IOV_ITER_TYPES, 1,
	[iov_iter types are available])
	],[
	AC_MSG_RESULT(no)
	enable_vfs_iov_iter="no"
	])

	AC_MSG_CHECKING([whether iov_iter_advance() is available])
	ZFS_LINUX_TEST_RESULT([iov_iter_advance], [
	AC_MSG_RESULT(yes)
	AC_DEFINE(HAVE_IOV_ITER_ADVANCE, 1,
	[iov_iter_advance() is available])
	],[
	AC_MSG_RESULT(no)
	enable_vfs_iov_iter="no"
	])

	AC_MSG_CHECKING([whether iov_iter_revert() is available])
	ZFS_LINUX_TEST_RESULT([iov_iter_revert], [
	AC_MSG_RESULT(yes)
	AC_DEFINE(HAVE_IOV_ITER_REVERT, 1,
	[iov_iter_revert() is available])
	],[
	AC_MSG_RESULT(no)
	enable_vfs_iov_iter="no"
	])

	AC_MSG_CHECKING([whether iov_iter_fault_in_readable() is available])
	ZFS_LINUX_TEST_RESULT([iov_iter_fault_in_readable], [
	AC_MSG_RESULT(yes)
	AC_DEFINE(HAVE_IOV_ITER_FAULT_IN_READABLE, 1,
	[iov_iter_fault_in_readable() is available])
	],[
	AC_MSG_RESULT(no)
	enable_vfs_iov_iter="no"
	])

	AC_MSG_CHECKING([whether iov_iter_count() is available])
	ZFS_LINUX_TEST_RESULT([iov_iter_count], [
	AC_MSG_RESULT(yes)
	AC_DEFINE(HAVE_IOV_ITER_COUNT, 1,
	[iov_iter_count() is available])
	],[
	AC_MSG_RESULT(no)
	enable_vfs_iov_iter="no"
	])

	AC_MSG_CHECKING([whether copy_to_iter() is available])
	ZFS_LINUX_TEST_RESULT([copy_to_iter], [
	AC_MSG_RESULT(yes)
	AC_DEFINE(HAVE_COPY_TO_ITER, 1,
	[copy_to_iter() is available])
	],[
	AC_MSG_RESULT(no)
	enable_vfs_iov_iter="no"
	])

	AC_MSG_CHECKING([whether copy_from_iter() is available])
	ZFS_LINUX_TEST_RESULT([copy_from_iter], [
	AC_MSG_RESULT(yes)
	AC_DEFINE(HAVE_COPY_FROM_ITER, 1,
	[copy_from_iter() is available])
	],[
	AC_MSG_RESULT(no)
	enable_vfs_iov_iter="no"
	])

	+ dnl #
	+ dnl # This checks for iov_iter_type() in linux/uio.h. It is not
	+ dnl # required, however, and the module will compiled without it
	+ dnl # using direct access of the member attribute
	+ dnl #
	+ AC_MSG_CHECKING([whether iov_iter_type() is available])
	+ ZFS_LINUX_TEST_RESULT([iov_iter_type], [
	+ AC_MSG_RESULT(yes)
	+ AC_DEFINE(HAVE_IOV_ITER_TYPE, 1,
	+ [iov_iter_type() is available])
	+ ],[
	+ AC_MSG_RESULT(no)
	+ ])
	+
	dnl #
	dnl # As of the 4.9 kernel support is provided for iovecs, kvecs,
	dnl # bvecs and pipes in the iov_iter structure. As long as the
	dnl # other support interfaces are all available the iov_iter can
	dnl # be correctly used in the uio structure.
	dnl #
	AS_IF([test "x$enable_vfs_iov_iter" = "xyes"], [
	AC_DEFINE(HAVE_VFS_IOV_ITER, 1,
	[All required iov_iter interfaces are available])
	])
	])
	diff --git a/sys/contrib/openzfs/config/kernel.m4 b/sys/contrib/openzfs/config/kernel.m4
	index 0b94f3bd9cb6..bdd3caed2b3d 100644
	--- a/sys/contrib/openzfs/config/kernel.m4
	+++ b/sys/contrib/openzfs/config/kernel.m4
	@@ -1,891 +1,893 @@
	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
	ZFS_AC_KERNEL_SRC_VFS_SET_PAGE_DIRTY_NOBUFFERS
	ZFS_AC_KERNEL_SRC_STANDALONE_LINUX_STDARG
	+ ZFS_AC_KERNEL_SRC_PAGEMAP_FOLIO_WAIT_BIT

	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
	ZFS_AC_KERNEL_VFS_SET_PAGE_DIRTY_NOBUFFERS
	ZFS_AC_KERNEL_STANDALONE_LINUX_STDARG
	+ ZFS_AC_KERNEL_PAGEMAP_FOLIO_WAIT_BIT
	])

	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 1af4356cde19..27041c054c26 100644
	--- a/sys/contrib/openzfs/config/zfs-build.m4
	+++ b/sys/contrib/openzfs/config/zfs-build.m4
	@@ -1,625 +1,626 @@
	AC_DEFUN([ZFS_AC_LICENSE], [
	AC_MSG_CHECKING([zfs author])
	AC_MSG_RESULT([$ZFS_META_AUTHOR])

	AC_MSG_CHECKING([zfs license])
	AC_MSG_RESULT([$ZFS_META_LICENSE])
	])

	AC_DEFUN([ZFS_AC_DEBUG_ENABLE], [
	DEBUG_CFLAGS="-Werror"
	DEBUG_CPPFLAGS="-DDEBUG -UNDEBUG"
	DEBUG_LDFLAGS=""
	DEBUG_ZFS="_with_debug"
	WITH_DEBUG="true"
	AC_DEFINE(ZFS_DEBUG, 1, [zfs debugging enabled])

	KERNEL_DEBUG_CFLAGS="-Werror"
	KERNEL_DEBUG_CPPFLAGS="-DDEBUG -UNDEBUG"
	])

	AC_DEFUN([ZFS_AC_DEBUG_DISABLE], [
	DEBUG_CFLAGS=""
	DEBUG_CPPFLAGS="-UDEBUG -DNDEBUG"
	DEBUG_LDFLAGS=""
	DEBUG_ZFS="_without_debug"
	WITH_DEBUG=""

	KERNEL_DEBUG_CFLAGS=""
	KERNEL_DEBUG_CPPFLAGS="-UDEBUG -DNDEBUG"
	])

	dnl #
	dnl # When debugging is enabled:
	dnl # - Enable all ASSERTs (-DDEBUG)
	dnl # - Promote all compiler warnings to errors (-Werror)
	dnl #
	dnl # (If INVARIANTS is detected, we need to force DEBUG, or strange panics
	dnl # can ensue.)
	dnl #
	AC_DEFUN([ZFS_AC_DEBUG], [
	AC_MSG_CHECKING([whether assertion support will be enabled])
	AC_ARG_ENABLE([debug],
	[AS_HELP_STRING([--enable-debug],
	[Enable compiler and code assertions @<:@default=no@:>@])],
	[],
	[enable_debug=no])

	AS_CASE(["x$enable_debug"],
	["xyes"],
	[ZFS_AC_DEBUG_ENABLE],
	["xno"],
	[ZFS_AC_DEBUG_DISABLE],
	[AC_MSG_ERROR([Unknown option $enable_debug])])

	AS_CASE(["x$enable_invariants"],
	["xyes"],
	[],
	["xno"],
	[],
	[ZFS_AC_DEBUG_INVARIANTS_DETECT])

	AS_CASE(["x$enable_invariants"],
	["xyes"],
	[ZFS_AC_DEBUG_ENABLE],
	["xno"],
	[],
	[AC_MSG_ERROR([Unknown option $enable_invariants])])

	AC_SUBST(DEBUG_CFLAGS)
	AC_SUBST(DEBUG_CPPFLAGS)
	AC_SUBST(DEBUG_LDFLAGS)
	AC_SUBST(DEBUG_ZFS)
	AC_SUBST(WITH_DEBUG)

	AC_SUBST(KERNEL_DEBUG_CFLAGS)
	AC_SUBST(KERNEL_DEBUG_CPPFLAGS)

	AC_MSG_RESULT([$enable_debug])
	])

	AC_DEFUN([ZFS_AC_DEBUGINFO_ENABLE], [
	DEBUG_CFLAGS="$DEBUG_CFLAGS -g -fno-inline $NO_IPA_SRA"

	KERNEL_DEBUG_CFLAGS="$KERNEL_DEBUG_CFLAGS -fno-inline $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_IMPLICIT_FALLTHROUGH
	ZFS_AC_CONFIG_ALWAYS_CC_FRAME_LARGER_THAN
	ZFS_AC_CONFIG_ALWAYS_CC_NO_FORMAT_TRUNCATION
	ZFS_AC_CONFIG_ALWAYS_CC_NO_FORMAT_ZERO_LENGTH
	ZFS_AC_CONFIG_ALWAYS_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
	ZFS_AC_CONFIG_ALWAYS_SHELLCHECK
	])

	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/configure.ac b/sys/contrib/openzfs/configure.ac
	index 6f34b210d2b7..ebc7b276a640 100644
	--- a/sys/contrib/openzfs/configure.ac
	+++ b/sys/contrib/openzfs/configure.ac
	@@ -1,417 +1,418 @@
	/*
	* This file is part of the ZFS Linux port.
	*
	* Copyright (c) 2009 Lawrence Livermore National Security, LLC.
	* Produced at Lawrence Livermore National Laboratory
	* Written by:
	* Brian Behlendorf <behlendorf1@llnl.gov>,
	* Herb Wartens <wartens2@llnl.gov>,
	* Jim Garlick <garlick@llnl.gov>
	* LLNL-CODE-403049
	*
	* 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
	*/

	AC_INIT(m4_esyscmd(grep ^Name: META \| cut -d ':' -f 2 \| tr -d ' \n'),
	m4_esyscmd(grep ^Version: META \| cut -d ':' -f 2 \| tr -d ' \n'))
	AC_LANG(C)
	ZFS_AC_META
	AC_CONFIG_AUX_DIR([config])
	AC_CONFIG_MACRO_DIR([config])
	AC_CANONICAL_TARGET
	AM_MAINTAINER_MODE
	m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES([yes])])
	AM_INIT_AUTOMAKE([subdir-objects])
	AC_CONFIG_HEADERS([zfs_config.h], [
	(mv zfs_config.h zfs_config.h.tmp &&
	awk -f ${ac_srcdir}/config/config.awk zfs_config.h.tmp >zfs_config.h &&
	rm zfs_config.h.tmp) \|\| exit 1])

	LT_INIT
	AC_PROG_INSTALL
	AC_PROG_CC
	AC_PROG_LN_S
	PKG_PROG_PKG_CONFIG
	AM_PROG_AS
	AM_PROG_CC_C_O
	AX_CODE_COVERAGE
	_AM_PROG_TAR(pax)

	ZFS_AC_LICENSE
	ZFS_AC_CONFIG
	ZFS_AC_PACKAGE
	ZFS_AC_DEBUG
	ZFS_AC_DEBUGINFO
	ZFS_AC_DEBUG_KMEM
	ZFS_AC_DEBUG_KMEM_TRACKING
	ZFS_AC_DEBUG_INVARIANTS

	AC_CONFIG_FILES([
	Makefile
	cmd/Makefile
	cmd/arc_summary/Makefile
	cmd/arcstat/Makefile
	cmd/dbufstat/Makefile
	cmd/fsck_zfs/Makefile
	cmd/mount_zfs/Makefile
	cmd/raidz_test/Makefile
	cmd/vdev_id/Makefile
	cmd/zdb/Makefile
	cmd/zed/Makefile
	cmd/zed/zed.d/Makefile
	cmd/zfs/Makefile
	cmd/zfs_ids_to_path/Makefile
	cmd/zgenhostid/Makefile
	cmd/zhack/Makefile
	cmd/zinject/Makefile
	cmd/zpool/Makefile
	cmd/zstream/Makefile
	cmd/ztest/Makefile
	cmd/zvol_id/Makefile
	cmd/zvol_wait/Makefile
	cmd/zpool_influxdb/Makefile
	contrib/Makefile
	contrib/bash_completion.d/Makefile
	contrib/bpftrace/Makefile
	contrib/dracut/02zfsexpandknowledge/Makefile
	contrib/dracut/90zfs/Makefile
	contrib/dracut/Makefile
	contrib/initramfs/Makefile
	contrib/initramfs/conf.d/Makefile
	contrib/initramfs/conf-hooks.d/Makefile
	contrib/initramfs/hooks/Makefile
	contrib/initramfs/scripts/Makefile
	contrib/initramfs/scripts/local-top/Makefile
	contrib/pam_zfs_key/Makefile
	contrib/pyzfs/Makefile
	contrib/pyzfs/setup.py
	contrib/zcp/Makefile
	etc/Makefile
	etc/default/Makefile
	etc/init.d/Makefile
	etc/modules-load.d/Makefile
	etc/sudoers.d/Makefile
	etc/systemd/Makefile
	etc/systemd/system-generators/Makefile
	etc/systemd/system/Makefile
	etc/zfs/Makefile
	include/Makefile
	include/os/Makefile
	include/os/freebsd/Makefile
	include/os/freebsd/linux/Makefile
	include/os/freebsd/spl/Makefile
	include/os/freebsd/spl/acl/Makefile
	include/os/freebsd/spl/rpc/Makefile
	include/os/freebsd/spl/sys/Makefile
	include/os/freebsd/zfs/Makefile
	include/os/freebsd/zfs/sys/Makefile
	include/os/linux/Makefile
	include/os/linux/kernel/Makefile
	include/os/linux/kernel/linux/Makefile
	include/os/linux/spl/Makefile
	include/os/linux/spl/rpc/Makefile
	include/os/linux/spl/sys/Makefile
	include/os/linux/zfs/Makefile
	include/os/linux/zfs/sys/Makefile
	include/sys/Makefile
	include/sys/crypto/Makefile
	include/sys/fm/Makefile
	include/sys/fm/fs/Makefile
	include/sys/fs/Makefile
	include/sys/lua/Makefile
	include/sys/sysevent/Makefile
	include/sys/zstd/Makefile
	lib/Makefile
	lib/libavl/Makefile
	lib/libefi/Makefile
	lib/libicp/Makefile
	lib/libnvpair/Makefile
	lib/libshare/Makefile
	lib/libspl/Makefile
	lib/libspl/include/Makefile
	lib/libspl/include/ia32/Makefile
	lib/libspl/include/ia32/sys/Makefile
	lib/libspl/include/os/Makefile
	lib/libspl/include/os/freebsd/Makefile
	lib/libspl/include/os/freebsd/sys/Makefile
	lib/libspl/include/os/linux/Makefile
	lib/libspl/include/os/linux/sys/Makefile
	lib/libspl/include/rpc/Makefile
	lib/libspl/include/sys/Makefile
	lib/libspl/include/sys/dktp/Makefile
	lib/libspl/include/util/Makefile
	lib/libtpool/Makefile
	lib/libunicode/Makefile
	lib/libuutil/Makefile
	lib/libzfs/Makefile
	lib/libzfs/libzfs.pc
	lib/libzfsbootenv/Makefile
	lib/libzfsbootenv/libzfsbootenv.pc
	lib/libzfs_core/Makefile
	lib/libzfs_core/libzfs_core.pc
	lib/libzpool/Makefile
	lib/libzstd/Makefile
	lib/libzutil/Makefile
	man/Makefile
	module/Kbuild
	module/Makefile
	module/avl/Makefile
	module/icp/Makefile
	module/lua/Makefile
	module/nvpair/Makefile
	module/os/linux/spl/Makefile
	module/os/linux/zfs/Makefile
	module/spl/Makefile
	module/unicode/Makefile
	module/zcommon/Makefile
	module/zfs/Makefile
	module/zstd/Makefile
	rpm/Makefile
	rpm/generic/Makefile
	rpm/generic/zfs-dkms.spec
	rpm/generic/zfs-kmod.spec
	rpm/generic/zfs.spec
	rpm/redhat/Makefile
	rpm/redhat/zfs-dkms.spec
	rpm/redhat/zfs-kmod.spec
	rpm/redhat/zfs.spec
	scripts/Makefile
	tests/Makefile
	tests/runfiles/Makefile
	tests/test-runner/Makefile
	tests/test-runner/bin/Makefile
	tests/test-runner/include/Makefile
	tests/test-runner/man/Makefile
	tests/zfs-tests/Makefile
	tests/zfs-tests/callbacks/Makefile
	tests/zfs-tests/cmd/Makefile
	tests/zfs-tests/cmd/badsend/Makefile
	tests/zfs-tests/cmd/btree_test/Makefile
	tests/zfs-tests/cmd/chg_usr_exec/Makefile
	tests/zfs-tests/cmd/devname2devid/Makefile
	tests/zfs-tests/cmd/draid/Makefile
	tests/zfs-tests/cmd/dir_rd_update/Makefile
	tests/zfs-tests/cmd/file_check/Makefile
	tests/zfs-tests/cmd/file_trunc/Makefile
	tests/zfs-tests/cmd/file_write/Makefile
	tests/zfs-tests/cmd/get_diff/Makefile
	tests/zfs-tests/cmd/largest_file/Makefile
	tests/zfs-tests/cmd/libzfs_input_check/Makefile
	tests/zfs-tests/cmd/mkbusy/Makefile
	tests/zfs-tests/cmd/mkfile/Makefile
	tests/zfs-tests/cmd/mkfiles/Makefile
	tests/zfs-tests/cmd/mktree/Makefile
	tests/zfs-tests/cmd/mmap_exec/Makefile
	tests/zfs-tests/cmd/mmap_libaio/Makefile
	+ tests/zfs-tests/cmd/mmap_seek/Makefile
	tests/zfs-tests/cmd/mmapwrite/Makefile
	tests/zfs-tests/cmd/nvlist_to_lua/Makefile
	tests/zfs-tests/cmd/randfree_file/Makefile
	tests/zfs-tests/cmd/randwritecomp/Makefile
	tests/zfs-tests/cmd/readmmap/Makefile
	tests/zfs-tests/cmd/rename_dir/Makefile
	tests/zfs-tests/cmd/rm_lnkcnt_zero_file/Makefile
	tests/zfs-tests/cmd/send_doall/Makefile
	tests/zfs-tests/cmd/stride_dd/Makefile
	tests/zfs-tests/cmd/threadsappend/Makefile
	tests/zfs-tests/cmd/user_ns_exec/Makefile
	tests/zfs-tests/cmd/xattrtest/Makefile
	tests/zfs-tests/include/Makefile
	tests/zfs-tests/tests/Makefile
	tests/zfs-tests/tests/functional/Makefile
	tests/zfs-tests/tests/functional/acl/Makefile
	tests/zfs-tests/tests/functional/acl/off/Makefile
	tests/zfs-tests/tests/functional/acl/posix/Makefile
	tests/zfs-tests/tests/functional/acl/posix-sa/Makefile
	tests/zfs-tests/tests/functional/alloc_class/Makefile
	tests/zfs-tests/tests/functional/arc/Makefile
	tests/zfs-tests/tests/functional/atime/Makefile
	tests/zfs-tests/tests/functional/bootfs/Makefile
	tests/zfs-tests/tests/functional/btree/Makefile
	tests/zfs-tests/tests/functional/cache/Makefile
	tests/zfs-tests/tests/functional/cachefile/Makefile
	tests/zfs-tests/tests/functional/casenorm/Makefile
	tests/zfs-tests/tests/functional/channel_program/Makefile
	tests/zfs-tests/tests/functional/channel_program/lua_core/Makefile
	tests/zfs-tests/tests/functional/channel_program/synctask_core/Makefile
	tests/zfs-tests/tests/functional/chattr/Makefile
	tests/zfs-tests/tests/functional/checksum/Makefile
	tests/zfs-tests/tests/functional/clean_mirror/Makefile
	tests/zfs-tests/tests/functional/cli_root/Makefile
	tests/zfs-tests/tests/functional/cli_root/zdb/Makefile
	tests/zfs-tests/tests/functional/cli_root/zfs/Makefile
	tests/zfs-tests/tests/functional/cli_root/zfs_bookmark/Makefile
	tests/zfs-tests/tests/functional/cli_root/zfs_change-key/Makefile
	tests/zfs-tests/tests/functional/cli_root/zfs_clone/Makefile
	tests/zfs-tests/tests/functional/cli_root/zfs_copies/Makefile
	tests/zfs-tests/tests/functional/cli_root/zfs_create/Makefile
	tests/zfs-tests/tests/functional/cli_root/zfs_destroy/Makefile
	tests/zfs-tests/tests/functional/cli_root/zfs_diff/Makefile
	tests/zfs-tests/tests/functional/cli_root/zfs_get/Makefile
	tests/zfs-tests/tests/functional/cli_root/zfs_ids_to_path/Makefile
	tests/zfs-tests/tests/functional/cli_root/zfs_inherit/Makefile
	tests/zfs-tests/tests/functional/cli_root/zfs_jail/Makefile
	tests/zfs-tests/tests/functional/cli_root/zfs_load-key/Makefile
	tests/zfs-tests/tests/functional/cli_root/zfs_mount/Makefile
	tests/zfs-tests/tests/functional/cli_root/zfs_program/Makefile
	tests/zfs-tests/tests/functional/cli_root/zfs_promote/Makefile
	tests/zfs-tests/tests/functional/cli_root/zfs_property/Makefile
	tests/zfs-tests/tests/functional/cli_root/zfs_receive/Makefile
	tests/zfs-tests/tests/functional/cli_root/zfs_rename/Makefile
	tests/zfs-tests/tests/functional/cli_root/zfs_reservation/Makefile
	tests/zfs-tests/tests/functional/cli_root/zfs_rollback/Makefile
	tests/zfs-tests/tests/functional/cli_root/zfs_send/Makefile
	tests/zfs-tests/tests/functional/cli_root/zfs_set/Makefile
	tests/zfs-tests/tests/functional/cli_root/zfs_share/Makefile
	tests/zfs-tests/tests/functional/cli_root/zfs_snapshot/Makefile
	tests/zfs-tests/tests/functional/cli_root/zfs_sysfs/Makefile
	tests/zfs-tests/tests/functional/cli_root/zfs_unload-key/Makefile
	tests/zfs-tests/tests/functional/cli_root/zfs_unmount/Makefile
	tests/zfs-tests/tests/functional/cli_root/zfs_unshare/Makefile
	tests/zfs-tests/tests/functional/cli_root/zfs_upgrade/Makefile
	tests/zfs-tests/tests/functional/cli_root/zfs_wait/Makefile
	tests/zfs-tests/tests/functional/cli_root/zpool/Makefile
	tests/zfs-tests/tests/functional/cli_root/zpool_add/Makefile
	tests/zfs-tests/tests/functional/cli_root/zpool_attach/Makefile
	tests/zfs-tests/tests/functional/cli_root/zpool_clear/Makefile
	tests/zfs-tests/tests/functional/cli_root/zpool_create/Makefile
	tests/zfs-tests/tests/functional/cli_root/zpool_destroy/Makefile
	tests/zfs-tests/tests/functional/cli_root/zpool_detach/Makefile
	tests/zfs-tests/tests/functional/cli_root/zpool_events/Makefile
	tests/zfs-tests/tests/functional/cli_root/zpool_expand/Makefile
	tests/zfs-tests/tests/functional/cli_root/zpool_export/Makefile
	tests/zfs-tests/tests/functional/cli_root/zpool_get/Makefile
	tests/zfs-tests/tests/functional/cli_root/zpool_history/Makefile
	tests/zfs-tests/tests/functional/cli_root/zpool_import/Makefile
	tests/zfs-tests/tests/functional/cli_root/zpool_import/blockfiles/Makefile
	tests/zfs-tests/tests/functional/cli_root/zpool_initialize/Makefile
	tests/zfs-tests/tests/functional/cli_root/zpool_labelclear/Makefile
	tests/zfs-tests/tests/functional/cli_root/zpool_offline/Makefile
	tests/zfs-tests/tests/functional/cli_root/zpool_online/Makefile
	tests/zfs-tests/tests/functional/cli_root/zpool_remove/Makefile
	tests/zfs-tests/tests/functional/cli_root/zpool_reopen/Makefile
	tests/zfs-tests/tests/functional/cli_root/zpool_replace/Makefile
	tests/zfs-tests/tests/functional/cli_root/zpool_resilver/Makefile
	tests/zfs-tests/tests/functional/cli_root/zpool_scrub/Makefile
	tests/zfs-tests/tests/functional/cli_root/zpool_set/Makefile
	tests/zfs-tests/tests/functional/cli_root/zpool_split/Makefile
	tests/zfs-tests/tests/functional/cli_root/zpool_status/Makefile
	tests/zfs-tests/tests/functional/cli_root/zpool_sync/Makefile
	tests/zfs-tests/tests/functional/cli_root/zpool_trim/Makefile
	tests/zfs-tests/tests/functional/cli_root/zpool_upgrade/Makefile
	tests/zfs-tests/tests/functional/cli_root/zpool_upgrade/blockfiles/Makefile
	tests/zfs-tests/tests/functional/cli_root/zpool_wait/Makefile
	tests/zfs-tests/tests/functional/cli_root/zpool_wait/scan/Makefile
	tests/zfs-tests/tests/functional/cli_user/Makefile
	tests/zfs-tests/tests/functional/cli_user/misc/Makefile
	tests/zfs-tests/tests/functional/cli_user/zfs_list/Makefile
	tests/zfs-tests/tests/functional/cli_user/zpool_iostat/Makefile
	tests/zfs-tests/tests/functional/cli_user/zpool_list/Makefile
	tests/zfs-tests/tests/functional/cli_user/zpool_status/Makefile
	tests/zfs-tests/tests/functional/compression/Makefile
	tests/zfs-tests/tests/functional/cp_files/Makefile
	tests/zfs-tests/tests/functional/crtime/Makefile
	tests/zfs-tests/tests/functional/ctime/Makefile
	tests/zfs-tests/tests/functional/deadman/Makefile
	tests/zfs-tests/tests/functional/delegate/Makefile
	tests/zfs-tests/tests/functional/devices/Makefile
	tests/zfs-tests/tests/functional/events/Makefile
	tests/zfs-tests/tests/functional/exec/Makefile
	tests/zfs-tests/tests/functional/fallocate/Makefile
	tests/zfs-tests/tests/functional/fault/Makefile
	tests/zfs-tests/tests/functional/features/Makefile
	tests/zfs-tests/tests/functional/features/async_destroy/Makefile
	tests/zfs-tests/tests/functional/features/large_dnode/Makefile
	tests/zfs-tests/tests/functional/grow/Makefile
	tests/zfs-tests/tests/functional/history/Makefile
	tests/zfs-tests/tests/functional/hkdf/Makefile
	tests/zfs-tests/tests/functional/inheritance/Makefile
	tests/zfs-tests/tests/functional/inuse/Makefile
	tests/zfs-tests/tests/functional/io/Makefile
	tests/zfs-tests/tests/functional/l2arc/Makefile
	tests/zfs-tests/tests/functional/large_files/Makefile
	tests/zfs-tests/tests/functional/largest_pool/Makefile
	tests/zfs-tests/tests/functional/libzfs/Makefile
	tests/zfs-tests/tests/functional/limits/Makefile
	tests/zfs-tests/tests/functional/link_count/Makefile
	tests/zfs-tests/tests/functional/log_spacemap/Makefile
	tests/zfs-tests/tests/functional/migration/Makefile
	tests/zfs-tests/tests/functional/mmap/Makefile
	tests/zfs-tests/tests/functional/mmp/Makefile
	tests/zfs-tests/tests/functional/mount/Makefile
	tests/zfs-tests/tests/functional/mv_files/Makefile
	tests/zfs-tests/tests/functional/nestedfs/Makefile
	tests/zfs-tests/tests/functional/no_space/Makefile
	tests/zfs-tests/tests/functional/nopwrite/Makefile
	tests/zfs-tests/tests/functional/online_offline/Makefile
	tests/zfs-tests/tests/functional/pam/Makefile
	tests/zfs-tests/tests/functional/pool_checkpoint/Makefile
	tests/zfs-tests/tests/functional/pool_names/Makefile
	tests/zfs-tests/tests/functional/poolversion/Makefile
	tests/zfs-tests/tests/functional/privilege/Makefile
	tests/zfs-tests/tests/functional/procfs/Makefile
	tests/zfs-tests/tests/functional/projectquota/Makefile
	tests/zfs-tests/tests/functional/pyzfs/Makefile
	tests/zfs-tests/tests/functional/quota/Makefile
	tests/zfs-tests/tests/functional/raidz/Makefile
	tests/zfs-tests/tests/functional/redacted_send/Makefile
	tests/zfs-tests/tests/functional/redundancy/Makefile
	tests/zfs-tests/tests/functional/refquota/Makefile
	tests/zfs-tests/tests/functional/refreserv/Makefile
	tests/zfs-tests/tests/functional/removal/Makefile
	tests/zfs-tests/tests/functional/rename_dirs/Makefile
	tests/zfs-tests/tests/functional/replacement/Makefile
	tests/zfs-tests/tests/functional/reservation/Makefile
	tests/zfs-tests/tests/functional/rootpool/Makefile
	tests/zfs-tests/tests/functional/rsend/Makefile
	tests/zfs-tests/tests/functional/scrub_mirror/Makefile
	tests/zfs-tests/tests/functional/slog/Makefile
	tests/zfs-tests/tests/functional/snapshot/Makefile
	tests/zfs-tests/tests/functional/snapused/Makefile
	tests/zfs-tests/tests/functional/sparse/Makefile
	tests/zfs-tests/tests/functional/suid/Makefile
	tests/zfs-tests/tests/functional/threadsappend/Makefile
	tests/zfs-tests/tests/functional/tmpfile/Makefile
	tests/zfs-tests/tests/functional/trim/Makefile
	tests/zfs-tests/tests/functional/truncate/Makefile
	tests/zfs-tests/tests/functional/upgrade/Makefile
	tests/zfs-tests/tests/functional/user_namespace/Makefile
	tests/zfs-tests/tests/functional/userquota/Makefile
	tests/zfs-tests/tests/functional/vdev_zaps/Makefile
	tests/zfs-tests/tests/functional/write_dirs/Makefile
	tests/zfs-tests/tests/functional/xattr/Makefile
	tests/zfs-tests/tests/functional/zpool_influxdb/Makefile
	tests/zfs-tests/tests/functional/zvol/Makefile
	tests/zfs-tests/tests/functional/zvol/zvol_ENOSPC/Makefile
	tests/zfs-tests/tests/functional/zvol/zvol_cli/Makefile
	tests/zfs-tests/tests/functional/zvol/zvol_misc/Makefile
	tests/zfs-tests/tests/functional/zvol/zvol_swap/Makefile
	tests/zfs-tests/tests/perf/Makefile
	tests/zfs-tests/tests/perf/fio/Makefile
	tests/zfs-tests/tests/perf/regression/Makefile
	tests/zfs-tests/tests/perf/scripts/Makefile
	tests/zfs-tests/tests/stress/Makefile
	udev/Makefile
	udev/rules.d/Makefile
	zfs.release
	])


	AC_OUTPUT
	diff --git a/sys/contrib/openzfs/include/libzutil.h b/sys/contrib/openzfs/include/libzutil.h
	index 82a802678903..6b9facdf9cbe 100644
	--- a/sys/contrib/openzfs/include/libzutil.h
	+++ b/sys/contrib/openzfs/include/libzutil.h
	@@ -1,166 +1,176 @@
	/*
	* 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 by Delphix. All rights reserved.
	*/

	#ifndef _LIBZUTIL_H
	#define _LIBZUTIL_H

	#include <sys/nvpair.h>
	#include <sys/fs/zfs.h>

	#ifdef __cplusplus
	extern "C" {
	#endif

	/*
	* Default wait time for a device name to be created.
	*/
	#define DISK_LABEL_WAIT (30 * 1000) /* 30 seconds */


	/*
	* Pool Config Operations
	*
	* These are specific to the library libzfs or libzpool instance.
	*/
	typedef nvlist_t refresh_config_func_t(void , nvlist_t *);

	typedef int pool_active_func_t(void , const char , uint64_t, boolean_t *);

	typedef const struct pool_config_ops {
	refresh_config_func_t *pco_refresh_config;
	pool_active_func_t *pco_pool_active;
	} pool_config_ops_t;

	/*
	* An instance of pool_config_ops_t is expected in the caller's binary.
	*/
	extern const pool_config_ops_t libzfs_config_ops;
	extern const pool_config_ops_t libzpool_config_ops;

	typedef struct importargs {
	char *path; / a list of paths to search */
	int paths; /* number of paths to search */
	const char poolname; / name of a pool to find */
	uint64_t guid; /* guid of a pool to find */
	const char cachefile; / cachefile to use for import */
	boolean_t can_be_active; /* can the pool be active? */
	boolean_t scan; /* prefer scanning to libblkid cache */
	nvlist_t policy; / load policy (max txg, rewind, etc.) */
	} importargs_t;

	extern nvlist_t zpool_search_import(void , importargs_t *,
	const pool_config_ops_t *);
	extern int zpool_find_config(void , const char , nvlist_t *, importargs_t ,
	const pool_config_ops_t *);

	extern const char * const * zpool_default_search_paths(size_t *count);
	extern int zpool_read_label(int, nvlist_t *, int );
	extern int zpool_label_disk_wait(const char *, int);

	struct udev_device;

	extern int zfs_device_get_devid(struct udev_device , char , size_t);
	extern int zfs_device_get_physical(struct udev_device , char , size_t);

	extern void update_vdev_config_dev_strs(nvlist_t *);

	/*
	* Default device paths
	*/
	#define DISK_ROOT "/dev"
	#define UDISK_ROOT "/dev/disk"
	#define ZVOL_ROOT "/dev/zvol"

	extern int zfs_append_partition(char *path, size_t max_len);
	extern int zfs_resolve_shortname(const char name, char path, size_t pathlen);

	extern char zfs_strip_partition(char );
	extern char zfs_strip_path(char );

	extern int zfs_strcmp_pathname(const char , const char , int);

	extern boolean_t zfs_dev_is_dm(const char *);
	extern boolean_t zfs_dev_is_whole_disk(const char *);
	extern int zfs_dev_flush(int);
	extern char zfs_get_underlying_path(const char );
	extern char zfs_get_enclosure_sysfs_path(const char );

	extern boolean_t is_mpath_whole_disk(const char *);

	extern boolean_t zfs_isnumber(const char *);

	/*
	* Formats for iostat numbers. Examples: "12K", "30ms", "4B", "2321234", "-".
	*
	* ZFS_NICENUM_1024: Print kilo, mega, tera, peta, exa..
	* ZFS_NICENUM_BYTES: Print single bytes ("13B"), kilo, mega, tera...
	* ZFS_NICENUM_TIME: Print nanosecs, microsecs, millisecs, seconds...
	* ZFS_NICENUM_RAW: Print the raw number without any formatting
	* ZFS_NICENUM_RAWTIME: Same as RAW, but print dashes ('-') for zero.
	*/
	enum zfs_nicenum_format {
	ZFS_NICENUM_1024 = 0,
	ZFS_NICENUM_BYTES = 1,
	ZFS_NICENUM_TIME = 2,
	ZFS_NICENUM_RAW = 3,
	ZFS_NICENUM_RAWTIME = 4
	};

	/*
	* Convert a number to a human-readable form.
	*/
	extern void zfs_nicebytes(uint64_t, char *, size_t);
	extern void zfs_nicenum(uint64_t, char *, size_t);
	extern void zfs_nicenum_format(uint64_t, char *, size_t,
	enum zfs_nicenum_format);
	extern void zfs_nicetime(uint64_t, char *, size_t);
	extern void zfs_niceraw(uint64_t, char *, size_t);

	#define nicenum(num, buf, size) zfs_nicenum(num, buf, size)

	extern void zpool_dump_ddt(const ddt_stat_t , const ddt_histogram_t );
	extern int zpool_history_unpack(char , uint64_t, uint64_t , nvlist_t ***,
	uint_t *);

	struct zfs_cmd;
	int zfs_ioctl_fd(int fd, unsigned long request, struct zfs_cmd *zc);

	/*
	* List of colors to use
	*/
	#define ANSI_RED "\033[0;31m"
	#define ANSI_YELLOW "\033[0;33m"
	#define ANSI_RESET "\033[0m"
	#define ANSI_BOLD "\033[1m"

	void color_start(char *color);
	void color_end(void);
	int printf_color(char color, char format, ...);

	+/*
	+ * These functions are used by the ZFS libraries and cmd/zpool code, but are
	+ * not exported in the ABI.
	+ */
	+typedef int (pool_vdev_iter_f)(void , nvlist_t , void );
	+int for_each_vdev_cb(void zhp, nvlist_t nv, pool_vdev_iter_f func,
	+ void *data);
	+int for_each_vdev_in_nvlist(nvlist_t *nvroot, pool_vdev_iter_f func,
	+ void *data);
	+void update_vdevs_config_dev_sysfs_path(nvlist_t *config);
	#ifdef __cplusplus
	}
	#endif

	#endif /* _LIBZUTIL_H */
	diff --git a/sys/contrib/openzfs/include/os/freebsd/linux/compiler.h b/sys/contrib/openzfs/include/os/freebsd/linux/compiler.h
	index 05e93efa64d7..20903717b58d 100644
	--- a/sys/contrib/openzfs/include/os/freebsd/linux/compiler.h
	+++ b/sys/contrib/openzfs/include/os/freebsd/linux/compiler.h
	@@ -1,101 +1,102 @@
	/*
	* Copyright (c) 2010 Isilon Systems, Inc.
	* Copyright (c) 2010 iXsystems, Inc.
	* Copyright (c) 2010 Panasas, Inc.
	* Copyright (c) 2013-2016 Mellanox Technologies, Ltd.
	* Copyright (c) 2015 François Tigeot
	* 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 unmodified, 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 AUTHOR ``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 AUTHOR 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 _LINUX_COMPILER_H_
	#define _LINUX_COMPILER_H_

	#include <sys/cdefs.h>

	#define __user
	#define __kernel
	#define __safe
	#define __force
	#define __nocast
	#define __iomem
	#define __chk_user_ptr(x) ((void)0)
	#define __chk_io_ptr(x) ((void)0)
	#define __builtin_warning(x, y...) (1)
	#define __acquires(x)
	#define __releases(x)
	#define __acquire(x) do { } while (0)
	#define __release(x) do { } while (0)
	#define __cond_lock(x, c) (c)
	#define __bitwise
	#define __devinitdata
	#define __deprecated
	#define __init
	#define __initconst
	#define __devinit
	#define __devexit
	#define __exit
	#define __rcu
	#define __percpu
	#define __weak __weak_symbol
	#define __malloc
	#define ___stringify(...) #__VA_ARGS__
	#define __stringify(...) ___stringify(__VA_ARGS__)
	#define __attribute_const__ __attribute__((__const__))
	#undef __always_inline
	#define __always_inline inline
	#define noinline __noinline
	#define ____cacheline_aligned __aligned(CACHE_LINE_SIZE)
	+#define fallthrough __attribute__((__fallthrough__))

	#if !defined(_KERNEL) && !defined(_STANDALONE)
	#define likely(x) __builtin_expect(!!(x), 1)
	#define unlikely(x) __builtin_expect(!!(x), 0)
	#endif
	#define typeof(x) __typeof(x)

	#define uninitialized_var(x) x = x
	#define __maybe_unused __unused
	#define __always_unused __unused
	#define __must_check __result_use_check

	#define __printf(a, b) __printflike(a, b)

	#define barrier() __asm__ __volatile__("": : :"memory")
	#define smp_rmb() rmb()
	#define ___PASTE(a, b) a##b
	#define __PASTE(a, b) ___PASTE(a, b)

	#define ACCESS_ONCE(x) ((volatile __typeof(x) )&(x))

	#define WRITE_ONCE(x, v) do { \
	barrier(); \
	ACCESS_ONCE(x) = (v); \
	barrier(); \
	} while (0)

	#define lockless_dereference(p) READ_ONCE(p)

	#define _AT(T, X) ((T)(X))

	#endif /* _LINUX_COMPILER_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 3670712a0456..1ac595aa15dd 100644
	--- a/sys/contrib/openzfs/include/os/freebsd/spl/sys/vnode.h
	+++ b/sys/contrib/openzfs/include/os/freebsd/spl/sys/vnode.h
	@@ -1,208 +1,228 @@
	/*
	* 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>
	+#include <sys/vm.h>
	+#include <vm/vm_object.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 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)
	+
	+#ifndef IN_BASE
	+static __inline void
	+vn_flush_cached_data(vnode_t *vp, boolean_t sync)
	+{
	+#if __FreeBSD_version > 1300054
	+ if (vm_object_mightbedirty(vp->v_object)) {
	+#else
	+ if (vp->v_object->flags & OBJ_MIGHTBEDIRTY) {
	+#endif
	+ int flags = sync ? OBJPC_SYNC : 0;
	+ zfs_vmobject_wlock(vp->v_object);
	+ vm_object_page_clean(vp->v_object, 0, 0, flags);
	+ zfs_vmobject_wunlock(vp->v_object);
	+ }
	+}
	+#endif
	+
	#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/zfs/sys/zfs_context_os.h b/sys/contrib/openzfs/include/os/freebsd/zfs/sys/zfs_context_os.h
	index 8dbe907d098c..a32eb52c53c1 100644
	--- a/sys/contrib/openzfs/include/os/freebsd/zfs/sys/zfs_context_os.h
	+++ b/sys/contrib/openzfs/include/os/freebsd/zfs/sys/zfs_context_os.h
	@@ -1,86 +1,90 @@
	/*
	* 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 ZFS_CONTEXT_OS_H_
	#define ZFS_CONTEXT_OS_H_

	#include <sys/condvar.h>
	#include <sys/rwlock.h>
	#include <sys/sig.h>
	#include_next <sys/sdt.h>
	#include <sys/misc.h>
	#include <sys/kdb.h>
	#include <sys/pathname.h>
	#include <sys/conf.h>
	#include <sys/types.h>
	#include <sys/ccompat.h>
	#include <linux/types.h>

	+#if KSTACK_PAGES * PAGE_SIZE >= 16384
	+#define HAVE_LARGE_STACKS 1
	+#endif
	+
	#define cond_resched() kern_yield(PRI_USER)

	#define taskq_create_sysdc(a, b, d, e, p, dc, f) \
	(taskq_create(a, b, maxclsyspri, d, e, f))

	#define tsd_create(keyp, destructor) do { \
	*(keyp) = osd_thread_register((destructor)); \
	KASSERT(*(keyp) > 0, ("cannot register OSD")); \
	} while (0)

	#define tsd_destroy(keyp) osd_thread_deregister(*(keyp))
	#define tsd_get(key) osd_thread_get(curthread, (key))
	#define tsd_set(key, value) osd_thread_set(curthread, (key), (value))
	#define fm_panic panic

	extern int zfs_debug_level;
	extern struct mtx zfs_debug_mtx;
	#define ZFS_LOG(lvl, ...) do { \
	if (((lvl) & 0xff) <= zfs_debug_level) { \
	mtx_lock(&zfs_debug_mtx); \
	printf("%s:%u[%d]: ", \
	__func__, __LINE__, (lvl)); \
	printf(__VA_ARGS__); \
	printf("\n"); \
	if ((lvl) & 0x100) \
	kdb_backtrace(); \
	mtx_unlock(&zfs_debug_mtx); \
	} \
	} while (0)

	#define MSEC_TO_TICK(msec) (howmany((hrtime_t)(msec) * hz, MILLISEC))
	extern int hz;
	extern int tick;
	typedef int fstrans_cookie_t;
	#define spl_fstrans_mark() (0)
	#define spl_fstrans_unmark(x) (x = 0)
	#define signal_pending(x) SIGPENDING(x)
	#define current curthread
	#define thread_join(x)
	typedef struct opensolaris_utsname utsname_t;
	extern utsname_t *utsname(void);
	extern int spa_import_rootpool(const char *name, bool checkpointrewind);
	#endif
	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 e90008c70a87..edb28d041a0c 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,189 @@
	/*
	* 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; \
	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_has_cached_data(zp) vn_has_cached_data(ZTOV(zp))
	+#define zn_flush_cached_data(zp, sync) vn_flush_cached_data(ZTOV(zp), sync)
	#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 019d5390adec..9fa8884bb7a1 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,582 +1,582 @@
	/*
	* 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/major.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 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)
	{
	#if !defined(HAVE_BLK_QUEUE_UPDATE_READAHEAD) && \
	!defined(HAVE_DISK_UPDATE_READAHEAD)
	#ifdef HAVE_BLK_QUEUE_BDI_DYNAMIC
	q->backing_dev_info->ra_pages = ra_pages;
	#else
	q->backing_dev_info.ra_pages = ra_pages;
	#endif
	#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 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_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
	* 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 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 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 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 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 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/compiler_compat.h b/sys/contrib/openzfs/include/os/linux/kernel/linux/compiler_compat.h
	index 921d32f246c5..2c0704da2e51 100644
	--- a/sys/contrib/openzfs/include/os/linux/kernel/linux/compiler_compat.h
	+++ b/sys/contrib/openzfs/include/os/linux/kernel/linux/compiler_compat.h
	@@ -1,35 +1,43 @@
	/*
	* 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 Lawrence Livermore National Security, LLC.
	*/

	#ifndef _ZFS_COMPILER_COMPAT_H
	#define _ZFS_COMPILER_COMPAT_H

	#include <linux/compiler.h>

	+#if !defined(fallthrough)
	+#if defined(HAVE_IMPLICIT_FALLTHROUGH)
	+#define fallthrough __attribute__((__fallthrough__))
	+#else
	+#define fallthrough ((void)0)
	+#endif
	+#endif
	+
	#if !defined(READ_ONCE)
	#define READ_ONCE(x) ACCESS_ONCE(x)
	#endif

	#endif /* _ZFS_COMPILER_COMPAT_H */
	diff --git a/sys/contrib/openzfs/include/os/linux/kernel/linux/simd_x86.h b/sys/contrib/openzfs/include/os/linux/kernel/linux/simd_x86.h
	index cdd3286d2147..f2ae0fcbc21a 100644
	--- a/sys/contrib/openzfs/include/os/linux/kernel/linux/simd_x86.h
	+++ b/sys/contrib/openzfs/include/os/linux/kernel/linux/simd_x86.h
	@@ -1,646 +1,649 @@
	/*
	* 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@compeng.uni-frankfurt.de>.
	*/

	/*
	* USER API:
	*
	* Kernel fpu methods:
	* kfpu_allowed()
	* kfpu_begin()
	* kfpu_end()
	* kfpu_init()
	* kfpu_fini()
	*
	* SIMD support:
	*
	* Following functions should be called to determine whether CPU feature
	* is supported. All functions are usable in kernel and user space.
	* If a SIMD algorithm is using more than one instruction set
	* all relevant feature test functions should be called.
	*
	* Supported features:
	* zfs_sse_available()
	* zfs_sse2_available()
	* zfs_sse3_available()
	* zfs_ssse3_available()
	* zfs_sse4_1_available()
	* zfs_sse4_2_available()
	*
	* zfs_avx_available()
	* zfs_avx2_available()
	*
	* zfs_bmi1_available()
	* zfs_bmi2_available()
	*
	* zfs_avx512f_available()
	* zfs_avx512cd_available()
	* zfs_avx512er_available()
	* zfs_avx512pf_available()
	* zfs_avx512bw_available()
	* zfs_avx512dq_available()
	* zfs_avx512vl_available()
	* zfs_avx512ifma_available()
	* zfs_avx512vbmi_available()
	*
	* NOTE(AVX-512VL): If using AVX-512 instructions with 128Bit registers
	* also add zfs_avx512vl_available() to feature check.
	*/

	#ifndef _LINUX_SIMD_X86_H
	#define _LINUX_SIMD_X86_H

	/* only for __x86 */
	#if defined(__x86)

	#include <sys/types.h>
	#include <asm/cpufeature.h>

	/*
	* Disable the WARN_ON_FPU() macro to prevent additional dependencies
	* when providing the kfpu_* functions. Relevant warnings are included
	* as appropriate and are unconditionally enabled.
	*/
	#if defined(CONFIG_X86_DEBUG_FPU) && !defined(KERNEL_EXPORTS_X86_FPU)
	#undef CONFIG_X86_DEBUG_FPU
	#endif

	#if defined(HAVE_KERNEL_FPU_API_HEADER)
	#include <asm/fpu/api.h>
	#include <asm/fpu/internal.h>
	+#if defined(HAVE_KERNEL_FPU_XCR_HEADER)
	+#include <asm/fpu/xcr.h>
	+#endif
	#else
	#include <asm/i387.h>
	#include <asm/xcr.h>
	#endif

	/*
	* The following cases are for kernels which export either the
	* kernel_fpu_* or __kernel_fpu_* functions.
	*/
	#if defined(KERNEL_EXPORTS_X86_FPU)

	#define kfpu_allowed() 1
	#define kfpu_init() 0
	#define kfpu_fini() ((void) 0)

	#if defined(HAVE_UNDERSCORE_KERNEL_FPU)
	#define kfpu_begin() \
	{ \
	preempt_disable(); \
	__kernel_fpu_begin(); \
	}
	#define kfpu_end() \
	{ \
	__kernel_fpu_end(); \
	preempt_enable(); \
	}

	#elif defined(HAVE_KERNEL_FPU)
	#define kfpu_begin() kernel_fpu_begin()
	#define kfpu_end() kernel_fpu_end()

	#else
	/*
	* This case is unreachable. When KERNEL_EXPORTS_X86_FPU is defined then
	* either HAVE_UNDERSCORE_KERNEL_FPU or HAVE_KERNEL_FPU must be defined.
	*/
	#error "Unreachable kernel configuration"
	#endif

	#else /* defined(KERNEL_EXPORTS_X86_FPU) */

	/*
	* When the kernel_fpu_* symbols are unavailable then provide our own
	* versions which allow the FPU to be safely used.
	*/
	#if defined(HAVE_KERNEL_FPU_INTERNAL)

	#include <linux/mm.h>

	extern union fpregs_state **zfs_kfpu_fpregs;

	/*
	* Initialize per-cpu variables to store FPU state.
	*/
	static inline void
	kfpu_fini(void)
	{
	int cpu;

	for_each_possible_cpu(cpu) {
	if (zfs_kfpu_fpregs[cpu] != NULL) {
	free_pages((unsigned long)zfs_kfpu_fpregs[cpu],
	get_order(sizeof (union fpregs_state)));
	}
	}

	kfree(zfs_kfpu_fpregs);
	}

	static inline int
	kfpu_init(void)
	{
	zfs_kfpu_fpregs = kzalloc(num_possible_cpus() *
	sizeof (union fpregs_state *), GFP_KERNEL);
	if (zfs_kfpu_fpregs == NULL)
	return (-ENOMEM);

	/*
	* The fxsave and xsave operations require 16-/64-byte alignment of
	* the target memory. Since kmalloc() provides no alignment
	* guarantee instead use alloc_pages_node().
	*/
	unsigned int order = get_order(sizeof (union fpregs_state));
	int cpu;

	for_each_possible_cpu(cpu) {
	struct page *page = alloc_pages_node(cpu_to_node(cpu),
	GFP_KERNEL \| __GFP_ZERO, order);
	if (page == NULL) {
	kfpu_fini();
	return (-ENOMEM);
	}

	zfs_kfpu_fpregs[cpu] = page_address(page);
	}

	return (0);
	}

	#define kfpu_allowed() 1
	#define ex_handler_fprestore ex_handler_default

	/*
	* FPU save and restore instructions.
	*/
	#define __asm __asm__ __volatile__
	#define kfpu_fxsave(addr) __asm("fxsave %0" : "=m" (*(addr)))
	#define kfpu_fxsaveq(addr) __asm("fxsaveq %0" : "=m" (*(addr)))
	#define kfpu_fnsave(addr) __asm("fnsave %0; fwait" : "=m" (*(addr)))
	#define kfpu_fxrstor(addr) __asm("fxrstor %0" : : "m" (*(addr)))
	#define kfpu_fxrstorq(addr) __asm("fxrstorq %0" : : "m" (*(addr)))
	#define kfpu_frstor(addr) __asm("frstor %0" : : "m" (*(addr)))
	#define kfpu_fxsr_clean(rval) __asm("fnclex; emms; fildl %P[addr]" \
	: : [addr] "m" (rval));

	static inline void
	kfpu_save_xsave(struct xregs_state *addr, uint64_t mask)
	{
	uint32_t low, hi;
	int err;

	low = mask;
	hi = mask >> 32;
	XSTATE_XSAVE(addr, low, hi, err);
	WARN_ON_ONCE(err);
	}

	static inline void
	kfpu_save_fxsr(struct fxregs_state *addr)
	{
	if (IS_ENABLED(CONFIG_X86_32))
	kfpu_fxsave(addr);
	else
	kfpu_fxsaveq(addr);
	}

	static inline void
	kfpu_save_fsave(struct fregs_state *addr)
	{
	kfpu_fnsave(addr);
	}

	static inline void
	kfpu_begin(void)
	{
	/*
	* Preemption and interrupts must be disabled for the critical
	* region where the FPU state is being modified.
	*/
	preempt_disable();
	local_irq_disable();

	/*
	* The current FPU registers need to be preserved by kfpu_begin()
	* and restored by kfpu_end(). They are stored in a dedicated
	* per-cpu variable, not in the task struct, this allows any user
	* FPU state to be correctly preserved and restored.
	*/
	union fpregs_state *state = zfs_kfpu_fpregs[smp_processor_id()];

	if (static_cpu_has(X86_FEATURE_XSAVE)) {
	kfpu_save_xsave(&state->xsave, ~0);
	} else if (static_cpu_has(X86_FEATURE_FXSR)) {
	kfpu_save_fxsr(&state->fxsave);
	} else {
	kfpu_save_fsave(&state->fsave);
	}
	}

	static inline void
	kfpu_restore_xsave(struct xregs_state *addr, uint64_t mask)
	{
	uint32_t low, hi;

	low = mask;
	hi = mask >> 32;
	XSTATE_XRESTORE(addr, low, hi);
	}

	static inline void
	kfpu_restore_fxsr(struct fxregs_state *addr)
	{
	/*
	* On AuthenticAMD K7 and K8 processors the fxrstor instruction only
	* restores the _x87 FOP, FIP, and FDP registers when an exception
	* is pending. Clean the _x87 state to force the restore.
	*/
	if (unlikely(static_cpu_has_bug(X86_BUG_FXSAVE_LEAK)))
	kfpu_fxsr_clean(addr);

	if (IS_ENABLED(CONFIG_X86_32)) {
	kfpu_fxrstor(addr);
	} else {
	kfpu_fxrstorq(addr);
	}
	}

	static inline void
	kfpu_restore_fsave(struct fregs_state *addr)
	{
	kfpu_frstor(addr);
	}

	static inline void
	kfpu_end(void)
	{
	union fpregs_state *state = zfs_kfpu_fpregs[smp_processor_id()];

	if (static_cpu_has(X86_FEATURE_XSAVE)) {
	kfpu_restore_xsave(&state->xsave, ~0);
	} else if (static_cpu_has(X86_FEATURE_FXSR)) {
	kfpu_restore_fxsr(&state->fxsave);
	} else {
	kfpu_restore_fsave(&state->fsave);
	}

	local_irq_enable();
	preempt_enable();
	}

	#else

	/*
	* FPU support is unavailable.
	*/
	#define kfpu_allowed() 0
	#define kfpu_begin() do {} while (0)
	#define kfpu_end() do {} while (0)
	#define kfpu_init() 0
	#define kfpu_fini() ((void) 0)

	#endif /* defined(HAVE_KERNEL_FPU_INTERNAL) */
	#endif /* defined(KERNEL_EXPORTS_X86_FPU) */

	/*
	* Linux kernel provides an interface for CPU feature testing.
	*/

	/*
	* Detect register set support
	*/
	static inline boolean_t
	__simd_state_enabled(const uint64_t state)
	{
	boolean_t has_osxsave;
	uint64_t xcr0;

	#if defined(X86_FEATURE_OSXSAVE)
	has_osxsave = !!boot_cpu_has(X86_FEATURE_OSXSAVE);
	#else
	has_osxsave = B_FALSE;
	#endif
	if (!has_osxsave)
	return (B_FALSE);

	xcr0 = xgetbv(0);
	return ((xcr0 & state) == state);
	}

	#define _XSTATE_SSE_AVX (0x2 \| 0x4)
	#define _XSTATE_AVX512 (0xE0 \| _XSTATE_SSE_AVX)

	#define __ymm_enabled() __simd_state_enabled(_XSTATE_SSE_AVX)
	#define __zmm_enabled() __simd_state_enabled(_XSTATE_AVX512)

	/*
	* Check if SSE instruction set is available
	*/
	static inline boolean_t
	zfs_sse_available(void)
	{
	return (!!boot_cpu_has(X86_FEATURE_XMM));
	}

	/*
	* Check if SSE2 instruction set is available
	*/
	static inline boolean_t
	zfs_sse2_available(void)
	{
	return (!!boot_cpu_has(X86_FEATURE_XMM2));
	}

	/*
	* Check if SSE3 instruction set is available
	*/
	static inline boolean_t
	zfs_sse3_available(void)
	{
	return (!!boot_cpu_has(X86_FEATURE_XMM3));
	}

	/*
	* Check if SSSE3 instruction set is available
	*/
	static inline boolean_t
	zfs_ssse3_available(void)
	{
	return (!!boot_cpu_has(X86_FEATURE_SSSE3));
	}

	/*
	* Check if SSE4.1 instruction set is available
	*/
	static inline boolean_t
	zfs_sse4_1_available(void)
	{
	return (!!boot_cpu_has(X86_FEATURE_XMM4_1));
	}

	/*
	* Check if SSE4.2 instruction set is available
	*/
	static inline boolean_t
	zfs_sse4_2_available(void)
	{
	return (!!boot_cpu_has(X86_FEATURE_XMM4_2));
	}

	/*
	* Check if AVX instruction set is available
	*/
	static inline boolean_t
	zfs_avx_available(void)
	{
	return (boot_cpu_has(X86_FEATURE_AVX) && __ymm_enabled());
	}

	/*
	* Check if AVX2 instruction set is available
	*/
	static inline boolean_t
	zfs_avx2_available(void)
	{
	return (boot_cpu_has(X86_FEATURE_AVX2) && __ymm_enabled());
	}

	/*
	* Check if BMI1 instruction set is available
	*/
	static inline boolean_t
	zfs_bmi1_available(void)
	{
	#if defined(X86_FEATURE_BMI1)
	return (!!boot_cpu_has(X86_FEATURE_BMI1));
	#else
	return (B_FALSE);
	#endif
	}

	/*
	* Check if BMI2 instruction set is available
	*/
	static inline boolean_t
	zfs_bmi2_available(void)
	{
	#if defined(X86_FEATURE_BMI2)
	return (!!boot_cpu_has(X86_FEATURE_BMI2));
	#else
	return (B_FALSE);
	#endif
	}

	/*
	* Check if AES instruction set is available
	*/
	static inline boolean_t
	zfs_aes_available(void)
	{
	#if defined(X86_FEATURE_AES)
	return (!!boot_cpu_has(X86_FEATURE_AES));
	#else
	return (B_FALSE);
	#endif
	}

	/*
	* Check if PCLMULQDQ instruction set is available
	*/
	static inline boolean_t
	zfs_pclmulqdq_available(void)
	{
	#if defined(X86_FEATURE_PCLMULQDQ)
	return (!!boot_cpu_has(X86_FEATURE_PCLMULQDQ));
	#else
	return (B_FALSE);
	#endif
	}

	/*
	* Check if MOVBE instruction is available
	*/
	static inline boolean_t
	zfs_movbe_available(void)
	{
	#if defined(X86_FEATURE_MOVBE)
	return (!!boot_cpu_has(X86_FEATURE_MOVBE));
	#else
	return (B_FALSE);
	#endif
	}

	/*
	* AVX-512 family of instruction sets:
	*
	* AVX512F Foundation
	* AVX512CD Conflict Detection Instructions
	* AVX512ER Exponential and Reciprocal Instructions
	* AVX512PF Prefetch Instructions
	*
	* AVX512BW Byte and Word Instructions
	* AVX512DQ Double-word and Quadword Instructions
	* AVX512VL Vector Length Extensions
	*
	* AVX512IFMA Integer Fused Multiply Add (Not supported by kernel 4.4)
	* AVX512VBMI Vector Byte Manipulation Instructions
	*/

	/*
	* Check if AVX512F instruction set is available
	*/
	static inline boolean_t
	zfs_avx512f_available(void)
	{
	boolean_t has_avx512 = B_FALSE;

	#if defined(X86_FEATURE_AVX512F)
	has_avx512 = !!boot_cpu_has(X86_FEATURE_AVX512F);
	#endif
	return (has_avx512 && __zmm_enabled());
	}

	/*
	* Check if AVX512CD instruction set is available
	*/
	static inline boolean_t
	zfs_avx512cd_available(void)
	{
	boolean_t has_avx512 = B_FALSE;

	#if defined(X86_FEATURE_AVX512CD)
	has_avx512 = boot_cpu_has(X86_FEATURE_AVX512F) &&
	boot_cpu_has(X86_FEATURE_AVX512CD);
	#endif
	return (has_avx512 && __zmm_enabled());
	}

	/*
	* Check if AVX512ER instruction set is available
	*/
	static inline boolean_t
	zfs_avx512er_available(void)
	{
	boolean_t has_avx512 = B_FALSE;

	#if defined(X86_FEATURE_AVX512ER)
	has_avx512 = boot_cpu_has(X86_FEATURE_AVX512F) &&
	boot_cpu_has(X86_FEATURE_AVX512ER);
	#endif
	return (has_avx512 && __zmm_enabled());
	}

	/*
	* Check if AVX512PF instruction set is available
	*/
	static inline boolean_t
	zfs_avx512pf_available(void)
	{
	boolean_t has_avx512 = B_FALSE;

	#if defined(X86_FEATURE_AVX512PF)
	has_avx512 = boot_cpu_has(X86_FEATURE_AVX512F) &&
	boot_cpu_has(X86_FEATURE_AVX512PF);
	#endif
	return (has_avx512 && __zmm_enabled());
	}

	/*
	* Check if AVX512BW instruction set is available
	*/
	static inline boolean_t
	zfs_avx512bw_available(void)
	{
	boolean_t has_avx512 = B_FALSE;

	#if defined(X86_FEATURE_AVX512BW)
	has_avx512 = boot_cpu_has(X86_FEATURE_AVX512F) &&
	boot_cpu_has(X86_FEATURE_AVX512BW);
	#endif

	return (has_avx512 && __zmm_enabled());
	}

	/*
	* Check if AVX512DQ instruction set is available
	*/
	static inline boolean_t
	zfs_avx512dq_available(void)
	{
	boolean_t has_avx512 = B_FALSE;

	#if defined(X86_FEATURE_AVX512DQ)
	has_avx512 = boot_cpu_has(X86_FEATURE_AVX512F) &&
	boot_cpu_has(X86_FEATURE_AVX512DQ);
	#endif
	return (has_avx512 && __zmm_enabled());
	}

	/*
	* Check if AVX512VL instruction set is available
	*/
	static inline boolean_t
	zfs_avx512vl_available(void)
	{
	boolean_t has_avx512 = B_FALSE;

	#if defined(X86_FEATURE_AVX512VL)
	has_avx512 = boot_cpu_has(X86_FEATURE_AVX512F) &&
	boot_cpu_has(X86_FEATURE_AVX512VL);
	#endif
	return (has_avx512 && __zmm_enabled());
	}

	/*
	* Check if AVX512IFMA instruction set is available
	*/
	static inline boolean_t
	zfs_avx512ifma_available(void)
	{
	boolean_t has_avx512 = B_FALSE;

	#if defined(X86_FEATURE_AVX512IFMA)
	has_avx512 = boot_cpu_has(X86_FEATURE_AVX512F) &&
	boot_cpu_has(X86_FEATURE_AVX512IFMA);
	#endif
	return (has_avx512 && __zmm_enabled());
	}

	/*
	* Check if AVX512VBMI instruction set is available
	*/
	static inline boolean_t
	zfs_avx512vbmi_available(void)
	{
	boolean_t has_avx512 = B_FALSE;

	#if defined(X86_FEATURE_AVX512VBMI)
	has_avx512 = boot_cpu_has(X86_FEATURE_AVX512F) &&
	boot_cpu_has(X86_FEATURE_AVX512VBMI);
	#endif
	return (has_avx512 && __zmm_enabled());
	}

	#endif /* defined(__x86) */

	#endif /* _LINUX_SIMD_X86_H */
	diff --git a/sys/contrib/openzfs/include/os/linux/zfs/sys/zfs_context_os.h b/sys/contrib/openzfs/include/os/linux/zfs/sys/zfs_context_os.h
	index de7015b929b6..9e4260558285 100644
	--- a/sys/contrib/openzfs/include/os/linux/zfs/sys/zfs_context_os.h
	+++ b/sys/contrib/openzfs/include/os/linux/zfs/sys/zfs_context_os.h
	@@ -1,29 +1,35 @@
	/*
	* 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
	*/

	#ifndef ZFS_CONTEXT_OS_H
	#define ZFS_CONTEXT_OS_H

	#include <linux/dcache_compat.h>
	#include <linux/utsname_compat.h>
	+#include <linux/compiler_compat.h>
	+#include <linux/module.h>
	+
	+#if THREAD_SIZE >= 16384
	+#define HAVE_LARGE_STACKS 1
	+#endif

	#endif
	diff --git a/sys/contrib/openzfs/include/os/linux/zfs/sys/zfs_znode_impl.h b/sys/contrib/openzfs/include/os/linux/zfs/sys/zfs_znode_impl.h
	index 0a6273442b71..de46fc8f2bd8 100644
	--- a/sys/contrib/openzfs/include/os/linux/zfs/sys/zfs_znode_impl.h
	+++ b/sys/contrib/openzfs/include/os/linux/zfs/sys/zfs_znode_impl.h
	@@ -1,182 +1,183 @@
	/*
	* 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 2016 Nexenta Systems, Inc. All rights reserved.
	*/

	#ifndef _SYS_ZFS_ZNODE_IMPL_H
	#define _SYS_ZFS_ZNODE_IMPL_H

	#ifndef _KERNEL
	#error "no user serviceable parts within"
	#endif

	#include <sys/isa_defs.h>
	#include <sys/types32.h>
	#include <sys/list.h>
	#include <sys/dmu.h>
	#include <sys/sa.h>
	#include <sys/time.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>

	#ifdef __cplusplus
	extern "C" {
	#endif

	#define ZNODE_OS_FIELDS \
	inode_timespec_t z_btime; /* creation/birth time (cached) */ \
	struct inode z_inode;

	/*
	* Convert between znode pointers and inode pointers
	*/
	#define ZTOI(znode) (&((znode)->z_inode))
	#define ITOZ(inode) (container_of((inode), znode_t, z_inode))
	#define ZTOZSB(znode) ((zfsvfs_t *)(ZTOI(znode)->i_sb->s_fs_info))
	#define ITOZSB(inode) ((zfsvfs_t *)((inode)->i_sb->s_fs_info))

	#define ZTOTYPE(zp) (ZTOI(zp)->i_mode)
	#define ZTOGID(zp) (ZTOI(zp)->i_gid)
	#define ZTOUID(zp) (ZTOI(zp)->i_uid)
	#define ZTONLNK(zp) (ZTOI(zp)->i_nlink)

	#define Z_ISBLK(type) S_ISBLK(type)
	#define Z_ISCHR(type) S_ISCHR(type)
	#define Z_ISLNK(type) S_ISLNK(type)
	#define Z_ISDEV(type) (S_ISCHR(type) \|\| S_ISBLK(type) \|\| S_ISFIFO(type))
	#define Z_ISDIR(type) S_ISDIR(type)

	#define zn_has_cached_data(zp) ((zp)->z_is_mapped)
	+#define zn_flush_cached_data(zp, sync) write_inode_now(ZTOI(zp), sync)
	#define zn_rlimit_fsize(zp, uio) (0)

	/*
	* zhold() wraps igrab() on Linux, and igrab() may fail when the
	* inode is in the process of being deleted. As zhold() must only be
	* called when a ref already exists - so the inode cannot be
	* mid-deletion - we VERIFY() this.
	*/
	#define zhold(zp) VERIFY3P(igrab(ZTOI((zp))), !=, NULL)
	#define zrele(zp) iput(ZTOI((zp)))

	/* Called on entry to each ZFS inode and vfs operation. */
	#define ZFS_ENTER_ERROR(zfsvfs, error) \
	do { \
	ZFS_TEARDOWN_ENTER_READ(zfsvfs, FTAG); \
	if (unlikely((zfsvfs)->z_unmounted)) { \
	ZFS_TEARDOWN_EXIT_READ(zfsvfs, FTAG); \
	return (error); \
	} \
	} while (0)
	#define ZFS_ENTER(zfsvfs) ZFS_ENTER_ERROR(zfsvfs, EIO)
	#define ZPL_ENTER(zfsvfs) ZFS_ENTER_ERROR(zfsvfs, -EIO)

	/* Must be called before exiting the operation. */
	#define ZFS_EXIT(zfsvfs) \
	do { \
	zfs_exit_fs(zfsvfs); \
	ZFS_TEARDOWN_EXIT_READ(zfsvfs, FTAG); \
	} while (0)

	#define ZPL_EXIT(zfsvfs) \
	do { \
	rrm_exit(&(zfsvfs)->z_teardown_lock, FTAG); \
	} while (0)

	/* Verifies the znode is valid. */
	#define ZFS_VERIFY_ZP_ERROR(zp, error) \
	do { \
	if (unlikely((zp)->z_sa_hdl == NULL)) { \
	ZFS_EXIT(ZTOZSB(zp)); \
	return (error); \
	} \
	} while (0)
	#define ZFS_VERIFY_ZP(zp) ZFS_VERIFY_ZP_ERROR(zp, EIO)
	#define ZPL_VERIFY_ZP(zp) ZFS_VERIFY_ZP_ERROR(zp, -EIO)

	/*
	* Macros for dealing with dmu_buf_hold
	*/
	#define ZFS_OBJ_MTX_SZ 64
	#define ZFS_OBJ_MTX_MAX (1024 * 1024)
	#define ZFS_OBJ_HASH(zfsvfs, obj) ((obj) & ((zfsvfs->z_hold_size) - 1))

	extern unsigned int zfs_object_mutex_size;

	/*
	* Encode ZFS stored time values from a struct timespec / struct timespec64.
	*/
	#define ZFS_TIME_ENCODE(tp, stmp) \
	do { \
	(stmp)[0] = (uint64_t)(tp)->tv_sec; \
	(stmp)[1] = (uint64_t)(tp)->tv_nsec; \
	} while (0)

	#if defined(HAVE_INODE_TIMESPEC64_TIMES)
	/*
	* Decode ZFS stored time values to a struct timespec64
	* 4.18 and newer kernels.
	*/
	#define ZFS_TIME_DECODE(tp, stmp) \
	do { \
	(tp)->tv_sec = (time64_t)(stmp)[0]; \
	(tp)->tv_nsec = (long)(stmp)[1]; \
	} while (0)
	#else
	/*
	* Decode ZFS stored time values to a struct timespec
	* 4.17 and older kernels.
	*/
	#define ZFS_TIME_DECODE(tp, stmp) \
	do { \
	(tp)->tv_sec = (time_t)(stmp)[0]; \
	(tp)->tv_nsec = (long)(stmp)[1]; \
	} while (0)
	#endif /* HAVE_INODE_TIMESPEC64_TIMES */

	#define ZFS_ACCESSTIME_STAMP(zfsvfs, zp)

	struct znode;

	extern int zfs_sync(struct super_block , int, cred_t );
	extern int zfs_inode_alloc(struct super_block , struct inode *ip);
	extern void zfs_inode_destroy(struct inode *);
	extern void zfs_mark_inode_dirty(struct inode *);
	extern boolean_t zfs_relatime_need_update(const struct inode *);

	#if defined(HAVE_UIO_RW)
	extern caddr_t zfs_map_page(page_t *, enum seg_rw);
	extern void zfs_unmap_page(page_t *, caddr_t);
	#endif /* HAVE_UIO_RW */

	extern zil_replay_func_t *zfs_replay_vector[TX_MAX_TYPE];
	extern int zfsfstype;

	#ifdef __cplusplus
	}
	#endif

	#endif /* _SYS_ZFS_ZNODE_IMPL_H */
	diff --git a/sys/contrib/openzfs/include/sys/dnode.h b/sys/contrib/openzfs/include/sys/dnode.h
	index 2cdc5b8798ad..af8775b9ee00 100644
	--- a/sys/contrib/openzfs/include/sys/dnode.h
	+++ b/sys/contrib/openzfs/include/sys/dnode.h
	@@ -1,627 +1,628 @@
	/*
	* 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) 2014 Spectra Logic Corporation, All rights reserved.
	*/

	#ifndef _SYS_DNODE_H
	#define _SYS_DNODE_H

	#include <sys/zfs_context.h>
	#include <sys/avl.h>
	#include <sys/spa.h>
	#include <sys/txg.h>
	#include <sys/zio.h>
	#include <sys/zfs_refcount.h>
	#include <sys/dmu_zfetch.h>
	#include <sys/zrlock.h>
	#include <sys/multilist.h>

	#ifdef __cplusplus
	extern "C" {
	#endif

	/*
	* dnode_hold() flags.
	*/
	#define DNODE_MUST_BE_ALLOCATED 1
	#define DNODE_MUST_BE_FREE 2
	#define DNODE_DRY_RUN 4

	/*
	* dnode_next_offset() flags.
	*/
	#define DNODE_FIND_HOLE 1
	#define DNODE_FIND_BACKWARDS 2
	#define DNODE_FIND_HAVELOCK 4

	/*
	* Fixed constants.
	*/
	#define DNODE_SHIFT 9 /* 512 bytes */
	#define DN_MIN_INDBLKSHIFT 12 /* 4k */
	/*
	* If we ever increase this value beyond 20, we need to revisit all logic that
	* does x << level * ebps to handle overflow. With a 1M indirect block size,
	* 4 levels of indirect blocks would not be able to guarantee addressing an
	* entire object, so 5 levels will be used, but 5 * (20 - 7) = 65.
	*/
	#define DN_MAX_INDBLKSHIFT 17 /* 128k */
	#define DNODE_BLOCK_SHIFT 14 /* 16k */
	#define DNODE_CORE_SIZE 64 /* 64 bytes for dnode sans blkptrs */
	#define DN_MAX_OBJECT_SHIFT 48 /* 256 trillion (zfs_fid_t limit) */
	#define DN_MAX_OFFSET_SHIFT 64 /* 2^64 bytes in a dnode */

	/*
	* dnode id flags
	*
	* Note: a file will never ever have its ids moved from bonus->spill
	*/
	#define DN_ID_CHKED_BONUS 0x1
	#define DN_ID_CHKED_SPILL 0x2
	#define DN_ID_OLD_EXIST 0x4
	#define DN_ID_NEW_EXIST 0x8

	/*
	* Derived constants.
	*/
	#define DNODE_MIN_SIZE (1 << DNODE_SHIFT)
	#define DNODE_MAX_SIZE (1 << DNODE_BLOCK_SHIFT)
	#define DNODE_BLOCK_SIZE (1 << DNODE_BLOCK_SHIFT)
	#define DNODE_MIN_SLOTS (DNODE_MIN_SIZE >> DNODE_SHIFT)
	#define DNODE_MAX_SLOTS (DNODE_MAX_SIZE >> DNODE_SHIFT)
	#define DN_BONUS_SIZE(dnsize) ((dnsize) - DNODE_CORE_SIZE - \
	(1 << SPA_BLKPTRSHIFT))
	#define DN_SLOTS_TO_BONUSLEN(slots) DN_BONUS_SIZE((slots) << DNODE_SHIFT)
	#define DN_OLD_MAX_BONUSLEN (DN_BONUS_SIZE(DNODE_MIN_SIZE))
	#define DN_MAX_NBLKPTR ((DNODE_MIN_SIZE - DNODE_CORE_SIZE) >> SPA_BLKPTRSHIFT)
	#define DN_MAX_OBJECT (1ULL << DN_MAX_OBJECT_SHIFT)
	#define DN_ZERO_BONUSLEN (DN_BONUS_SIZE(DNODE_MAX_SIZE) + 1)
	#define DN_KILL_SPILLBLK (1)

	#define DN_SLOT_UNINIT ((void )NULL) / Uninitialized */
	#define DN_SLOT_FREE ((void )1UL) / Free slot */
	#define DN_SLOT_ALLOCATED ((void )2UL) / Allocated slot */
	#define DN_SLOT_INTERIOR ((void )3UL) / Interior allocated slot */
	#define DN_SLOT_IS_PTR(dn) ((void *)dn > DN_SLOT_INTERIOR)
	#define DN_SLOT_IS_VALID(dn) ((void *)dn != NULL)

	#define DNODES_PER_BLOCK_SHIFT (DNODE_BLOCK_SHIFT - DNODE_SHIFT)
	#define DNODES_PER_BLOCK (1ULL << DNODES_PER_BLOCK_SHIFT)

	/*
	* This is inaccurate if the indblkshift of the particular object is not the
	* max. But it's only used by userland to calculate the zvol reservation.
	*/
	#define DNODES_PER_LEVEL_SHIFT (DN_MAX_INDBLKSHIFT - SPA_BLKPTRSHIFT)
	#define DNODES_PER_LEVEL (1ULL << DNODES_PER_LEVEL_SHIFT)

	#define DN_MAX_LEVELS (DIV_ROUND_UP(DN_MAX_OFFSET_SHIFT - SPA_MINBLOCKSHIFT, \
	DN_MIN_INDBLKSHIFT - SPA_BLKPTRSHIFT) + 1)

	#define DN_BONUS(dnp) ((void*)((dnp)->dn_bonus + \
	(((dnp)->dn_nblkptr - 1) * sizeof (blkptr_t))))
	#define DN_MAX_BONUS_LEN(dnp) \
	((dnp->dn_flags & DNODE_FLAG_SPILL_BLKPTR) ? \
	(uint8_t )DN_SPILL_BLKPTR(dnp) - (uint8_t )DN_BONUS(dnp) : \
	(uint8_t )(dnp + (dnp->dn_extra_slots + 1)) - (uint8_t )DN_BONUS(dnp))

	#define DN_USED_BYTES(dnp) (((dnp)->dn_flags & DNODE_FLAG_USED_BYTES) ? \
	(dnp)->dn_used : (dnp)->dn_used << SPA_MINBLOCKSHIFT)

	#define EPB(blkshift, typeshift) (1 << (blkshift - typeshift))

	struct dmu_buf_impl;
	struct objset;
	struct zio;

	enum dnode_dirtycontext {
	DN_UNDIRTIED,
	DN_DIRTY_OPEN,
	DN_DIRTY_SYNC
	};

	/* Is dn_used in bytes? if not, it's in multiples of SPA_MINBLOCKSIZE */
	#define DNODE_FLAG_USED_BYTES (1 << 0)
	#define DNODE_FLAG_USERUSED_ACCOUNTED (1 << 1)

	/* Does dnode have a SA spill blkptr in bonus? */
	#define DNODE_FLAG_SPILL_BLKPTR (1 << 2)

	/* User/Group/Project dnode accounting */
	#define DNODE_FLAG_USEROBJUSED_ACCOUNTED (1 << 3)

	/*
	* This mask defines the set of flags which are "portable", meaning
	* that they can be preserved when doing a raw encrypted zfs send.
	* Flags included in this mask will be protected by AAD when the block
	* of dnodes is encrypted.
	*/
	#define DNODE_CRYPT_PORTABLE_FLAGS_MASK (DNODE_FLAG_SPILL_BLKPTR)

	/*
	* VARIABLE-LENGTH (LARGE) DNODES
	*
	* The motivation for variable-length dnodes is to eliminate the overhead
	* associated with using spill blocks. Spill blocks are used to store
	* system attribute data (i.e. file metadata) that does not fit in the
	* dnode's bonus buffer. By allowing a larger bonus buffer area the use of
	* a spill block can be avoided. Spill blocks potentially incur an
	* additional read I/O for every dnode in a dnode block. As a worst case
	* example, reading 32 dnodes from a 16k dnode block and all of the spill
	* blocks could issue 33 separate reads. Now suppose those dnodes have size
	* 1024 and therefore don't need spill blocks. Then the worst case number
	* of blocks read is reduced from 33 to two--one per dnode block.
	*
	* ZFS-on-Linux systems that make heavy use of extended attributes benefit
	* from this feature. In particular, ZFS-on-Linux supports the xattr=sa
	* dataset property which allows file extended attribute data to be stored
	* in the dnode bonus buffer as an alternative to the traditional
	* directory-based format. Workloads such as SELinux and the Lustre
	* distributed filesystem often store enough xattr data to force spill
	* blocks when xattr=sa is in effect. Large dnodes may therefore provide a
	* performance benefit to such systems. Other use cases that benefit from
	* this feature include files with large ACLs and symbolic links with long
	* target names.
	*
	* The size of a dnode may be a multiple of 512 bytes up to the size of a
	* dnode block (currently 16384 bytes). The dn_extra_slots field of the
	* on-disk dnode_phys_t structure describes the size of the physical dnode
	* on disk. The field represents how many "extra" dnode_phys_t slots a
	* dnode consumes in its dnode block. This convention results in a value of
	* 0 for 512 byte dnodes which preserves on-disk format compatibility with
	* older software which doesn't support large dnodes.
	*
	* Similarly, the in-memory dnode_t structure has a dn_num_slots field
	* to represent the total number of dnode_phys_t slots consumed on disk.
	* Thus dn->dn_num_slots is 1 greater than the corresponding
	* dnp->dn_extra_slots. This difference in convention was adopted
	* because, unlike on-disk structures, backward compatibility is not a
	* concern for in-memory objects, so we used a more natural way to
	* represent size for a dnode_t.
	*
	* The default size for newly created dnodes is determined by the value of
	* the "dnodesize" dataset property. By default the property is set to
	* "legacy" which is compatible with older software. Setting the property
	* to "auto" will allow the filesystem to choose the most suitable dnode
	* size. Currently this just sets the default dnode size to 1k, but future
	* code improvements could dynamically choose a size based on observed
	* workload patterns. Dnodes of varying sizes can coexist within the same
	* dataset and even within the same dnode block.
	*/

	typedef struct dnode_phys {
	uint8_t dn_type; /* dmu_object_type_t */
	uint8_t dn_indblkshift; /* ln2(indirect block size) */
	uint8_t dn_nlevels; /* 1=dn_blkptr->data blocks */
	uint8_t dn_nblkptr; /* length of dn_blkptr */
	uint8_t dn_bonustype; /* type of data in bonus buffer */
	uint8_t dn_checksum; /* ZIO_CHECKSUM type */
	uint8_t dn_compress; /* ZIO_COMPRESS type */
	uint8_t dn_flags; /* DNODE_FLAG_* */
	uint16_t dn_datablkszsec; /* data block size in 512b sectors */
	uint16_t dn_bonuslen; /* length of dn_bonus */
	uint8_t dn_extra_slots; /* # of subsequent slots consumed */
	uint8_t dn_pad2[3];

	/* accounting is protected by dn_dirty_mtx */
	uint64_t dn_maxblkid; /* largest allocated block ID */
	uint64_t dn_used; /* bytes (or sectors) of disk space */

	/*
	* Both dn_pad2 and dn_pad3 are protected by the block's MAC. This
	* allows us to protect any fields that might be added here in the
	* future. In either case, developers will want to check
	* zio_crypt_init_uios_dnode() and zio_crypt_do_dnode_hmac_updates()
	* to ensure the new field is being protected and updated properly.
	*/
	uint64_t dn_pad3[4];

	/*
	* The tail region is 448 bytes for a 512 byte dnode, and
	* correspondingly larger for larger dnode sizes. The spill
	* block pointer, when present, is always at the end of the tail
	* region. There are three ways this space may be used, using
	* a 512 byte dnode for this diagram:
	*
	* 0 64 128 192 256 320 384 448 (offset)
	* +---------------+---------------+---------------+-------+
	* \| dn_blkptr[0] \| dn_blkptr[1] \| dn_blkptr[2] \| / \|
	* +---------------+---------------+---------------+-------+
	* \| dn_blkptr[0] \| dn_bonus[0..319] \|
	* +---------------+-----------------------+---------------+
	* \| dn_blkptr[0] \| dn_bonus[0..191] \| dn_spill \|
	* +---------------+-----------------------+---------------+
	*/
	union {
	blkptr_t dn_blkptr[1+DN_OLD_MAX_BONUSLEN/sizeof (blkptr_t)];
	struct {
	blkptr_t __dn_ignore1;
	uint8_t dn_bonus[DN_OLD_MAX_BONUSLEN];
	};
	struct {
	blkptr_t __dn_ignore2;
	uint8_t __dn_ignore3[DN_OLD_MAX_BONUSLEN -
	sizeof (blkptr_t)];
	blkptr_t dn_spill;
	};
	};
	} dnode_phys_t;

	#define DN_SPILL_BLKPTR(dnp) ((blkptr_t )((char )(dnp) + \
	(((dnp)->dn_extra_slots + 1) << DNODE_SHIFT) - (1 << SPA_BLKPTRSHIFT)))

	struct dnode {
	/*
	* Protects the structure of the dnode, including the number of levels
	* of indirection (dn_nlevels), dn_maxblkid, and dn_next_*
	*/
	krwlock_t dn_struct_rwlock;

	/* Our link on dn_objset->os_dnodes list; protected by os_lock. */
	list_node_t dn_link;

	/* immutable: */
	struct objset *dn_objset;
	uint64_t dn_object;
	struct dmu_buf_impl *dn_dbuf;
	struct dnode_handle *dn_handle;
	dnode_phys_t dn_phys; / pointer into dn->dn_dbuf->db.db_data */

	/*
	* Copies of stuff in dn_phys. They're valid in the open
	* context (eg. even before the dnode is first synced).
	* Where necessary, these are protected by dn_struct_rwlock.
	*/
	dmu_object_type_t dn_type; /* object type */
	uint16_t dn_bonuslen; /* bonus length */
	uint8_t dn_bonustype; /* bonus type */
	uint8_t dn_nblkptr; /* number of blkptrs (immutable) */
	uint8_t dn_checksum; /* ZIO_CHECKSUM type */
	uint8_t dn_compress; /* ZIO_COMPRESS type */
	uint8_t dn_nlevels;
	uint8_t dn_indblkshift;
	uint8_t dn_datablkshift; /* zero if blksz not power of 2! */
	uint8_t dn_moved; /* Has this dnode been moved? */
	uint16_t dn_datablkszsec; /* in 512b sectors */
	uint32_t dn_datablksz; /* in bytes */
	uint64_t dn_maxblkid;
	uint8_t dn_next_type[TXG_SIZE];
	uint8_t dn_num_slots; /* metadnode slots consumed on disk */
	uint8_t dn_next_nblkptr[TXG_SIZE];
	uint8_t dn_next_nlevels[TXG_SIZE];
	uint8_t dn_next_indblkshift[TXG_SIZE];
	uint8_t dn_next_bonustype[TXG_SIZE];
	uint8_t dn_rm_spillblk[TXG_SIZE]; /* for removing spill blk */
	uint16_t dn_next_bonuslen[TXG_SIZE];
	uint32_t dn_next_blksz[TXG_SIZE]; /* next block size in bytes */
	uint64_t dn_next_maxblkid[TXG_SIZE]; /* next maxblkid in bytes */

	/* protected by dn_dbufs_mtx; declared here to fill 32-bit hole */
	uint32_t dn_dbufs_count; /* count of dn_dbufs */

	/* protected by os_lock: */
	multilist_node_t dn_dirty_link[TXG_SIZE]; /* next on dataset's dirty */

	/* protected by dn_mtx: */
	kmutex_t dn_mtx;
	list_t dn_dirty_records[TXG_SIZE];
	struct range_tree *dn_free_ranges[TXG_SIZE];
	uint64_t dn_allocated_txg;
	uint64_t dn_free_txg;
	uint64_t dn_assigned_txg;
	uint64_t dn_dirty_txg; /* txg dnode was last dirtied */
	kcondvar_t dn_notxholds;
	kcondvar_t dn_nodnholds;
	enum dnode_dirtycontext dn_dirtyctx;
	void dn_dirtyctx_firstset; / dbg: contents meaningless */

	/* protected by own devices */
	zfs_refcount_t dn_tx_holds;
	zfs_refcount_t dn_holds;

	kmutex_t dn_dbufs_mtx;
	/*
	* Descendent dbufs, ordered by dbuf_compare. Note that dn_dbufs
	* can contain multiple dbufs of the same (level, blkid) when a
	* dbuf is marked DB_EVICTING without being removed from
	* dn_dbufs. To maintain the avl invariant that there cannot be
	* duplicate entries, we order the dbufs by an arbitrary value -
	* their address in memory. This means that dn_dbufs cannot be used to
	* directly look up a dbuf. Instead, callers must use avl_walk, have
	* a reference to the dbuf, or look up a non-existent node with
	* db_state = DB_SEARCH (see dbuf_free_range for an example).
	*/
	avl_tree_t dn_dbufs;

	/* protected by dn_struct_rwlock */
	struct dmu_buf_impl dn_bonus; / bonus buffer dbuf */

	boolean_t dn_have_spill; /* have spill or are spilling */

	/* parent IO for current sync write */
	zio_t *dn_zio;

	/* used in syncing context */
	uint64_t dn_oldused; /* old phys used bytes */
	uint64_t dn_oldflags; /* old phys dn_flags */
	uint64_t dn_olduid, dn_oldgid, dn_oldprojid;
	uint64_t dn_newuid, dn_newgid, dn_newprojid;
	int dn_id_flags;

	/* holds prefetch structure */
	struct zfetch dn_zfetch;
	};

	/*
	* Since AVL already has embedded element counter, use dn_dbufs_count
	* only for dbufs not counted there (bonus buffers) and just add them.
	*/
	#define DN_DBUFS_COUNT(dn) ((dn)->dn_dbufs_count + \
	avl_numnodes(&(dn)->dn_dbufs))

	/*
	* We use this (otherwise unused) bit to indicate if the value of
	* dn_next_maxblkid[txgoff] is valid to use in dnode_sync().
	*/
	#define DMU_NEXT_MAXBLKID_SET (1ULL << 63)

	/*
	* Adds a level of indirection between the dbuf and the dnode to avoid
	* iterating descendent dbufs in dnode_move(). Handles are not allocated
	* individually, but as an array of child dnodes in dnode_hold_impl().
	*/
	typedef struct dnode_handle {
	/* Protects dnh_dnode from modification by dnode_move(). */
	zrlock_t dnh_zrlock;
	dnode_t *dnh_dnode;
	} dnode_handle_t;

	typedef struct dnode_children {
	dmu_buf_user_t dnc_dbu; /* User evict data */
	size_t dnc_count; /* number of children */
	dnode_handle_t dnc_children[]; /* sized dynamically */
	} dnode_children_t;

	typedef struct free_range {
	avl_node_t fr_node;
	uint64_t fr_blkid;
	uint64_t fr_nblks;
	} free_range_t;

	void dnode_special_open(struct objset dd, dnode_phys_t dnp,
	uint64_t object, dnode_handle_t *dnh);
	void dnode_special_close(dnode_handle_t *dnh);

	void dnode_setbonuslen(dnode_t dn, int newsize, dmu_tx_t tx);
	void dnode_setbonus_type(dnode_t dn, dmu_object_type_t, dmu_tx_t tx);
	void dnode_rm_spill(dnode_t dn, dmu_tx_t tx);

	int dnode_hold(struct objset *dd, uint64_t object,
	void ref, dnode_t *dnp);
	int dnode_hold_impl(struct objset *dd, uint64_t object, int flag, int dn_slots,
	void ref, dnode_t *dnp);
	boolean_t dnode_add_ref(dnode_t dn, void ref);
	void dnode_rele(dnode_t dn, void ref);
	void dnode_rele_and_unlock(dnode_t dn, void tag, boolean_t evicting);
	int dnode_try_claim(objset_t *os, uint64_t object, int slots);
	+boolean_t dnode_is_dirty(dnode_t *dn);
	void dnode_setdirty(dnode_t dn, dmu_tx_t tx);
	void dnode_set_dirtyctx(dnode_t dn, dmu_tx_t tx, void *tag);
	void dnode_sync(dnode_t dn, dmu_tx_t tx);
	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);
	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);
	void dnode_free(dnode_t dn, dmu_tx_t tx);
	void dnode_byteswap(dnode_phys_t *dnp);
	void dnode_buf_byteswap(void *buf, size_t size);
	void dnode_verify(dnode_t *dn);
	int dnode_set_nlevels(dnode_t dn, int nlevels, dmu_tx_t tx);
	int dnode_set_blksz(dnode_t dn, uint64_t size, int ibs, dmu_tx_t tx);
	void dnode_free_range(dnode_t dn, uint64_t off, uint64_t len, dmu_tx_t tx);
	void dnode_diduse_space(dnode_t *dn, int64_t space);
	void dnode_new_blkid(dnode_t dn, uint64_t blkid, dmu_tx_t tx,
	boolean_t have_read, boolean_t force);
	uint64_t dnode_block_freed(dnode_t *dn, uint64_t blkid);
	void dnode_init(void);
	void dnode_fini(void);
	int dnode_next_offset(dnode_t dn, int flags, uint64_t off,
	int minlvl, uint64_t blkfill, uint64_t txg);
	void dnode_evict_dbufs(dnode_t *dn);
	void dnode_evict_bonus(dnode_t *dn);
	void dnode_free_interior_slots(dnode_t *dn);

	#define DNODE_IS_DIRTY(_dn) \
	((_dn)->dn_dirty_txg >= spa_syncing_txg((_dn)->dn_objset->os_spa))

	#define DNODE_IS_CACHEABLE(_dn) \
	((_dn)->dn_objset->os_primary_cache == ZFS_CACHE_ALL \|\| \
	(DMU_OT_IS_METADATA((_dn)->dn_type) && \
	(_dn)->dn_objset->os_primary_cache == ZFS_CACHE_METADATA))

	#define DNODE_META_IS_CACHEABLE(_dn) \
	((_dn)->dn_objset->os_primary_cache == ZFS_CACHE_ALL \|\| \
	(_dn)->dn_objset->os_primary_cache == ZFS_CACHE_METADATA)

	/*
	* Used for dnodestats kstat.
	*/
	typedef struct dnode_stats {
	/*
	* Number of failed attempts to hold a meta dnode dbuf.
	*/
	kstat_named_t dnode_hold_dbuf_hold;
	/*
	* Number of failed attempts to read a meta dnode dbuf.
	*/
	kstat_named_t dnode_hold_dbuf_read;
	/*
	* Number of times dnode_hold(..., DNODE_MUST_BE_ALLOCATED) was able
	* to hold the requested object number which was allocated. This is
	* the common case when looking up any allocated object number.
	*/
	kstat_named_t dnode_hold_alloc_hits;
	/*
	* Number of times dnode_hold(..., DNODE_MUST_BE_ALLOCATED) was not
	* able to hold the request object number because it was not allocated.
	*/
	kstat_named_t dnode_hold_alloc_misses;
	/*
	* Number of times dnode_hold(..., DNODE_MUST_BE_ALLOCATED) was not
	* able to hold the request object number because the object number
	* refers to an interior large dnode slot.
	*/
	kstat_named_t dnode_hold_alloc_interior;
	/*
	* Number of times dnode_hold(..., DNODE_MUST_BE_ALLOCATED) needed
	* to retry acquiring slot zrl locks due to contention.
	*/
	kstat_named_t dnode_hold_alloc_lock_retry;
	/*
	* Number of times dnode_hold(..., DNODE_MUST_BE_ALLOCATED) did not
	* need to create the dnode because another thread did so after
	* dropping the read lock but before acquiring the write lock.
	*/
	kstat_named_t dnode_hold_alloc_lock_misses;
	/*
	* Number of times dnode_hold(..., DNODE_MUST_BE_ALLOCATED) found
	* a free dnode instantiated by dnode_create() but not yet allocated
	* by dnode_allocate().
	*/
	kstat_named_t dnode_hold_alloc_type_none;
	/*
	* Number of times dnode_hold(..., DNODE_MUST_BE_FREE) was able
	* to hold the requested range of free dnode slots.
	*/
	kstat_named_t dnode_hold_free_hits;
	/*
	* Number of times dnode_hold(..., DNODE_MUST_BE_FREE) was not
	* able to hold the requested range of free dnode slots because
	* at least one slot was allocated.
	*/
	kstat_named_t dnode_hold_free_misses;
	/*
	* Number of times dnode_hold(..., DNODE_MUST_BE_FREE) was not
	* able to hold the requested range of free dnode slots because
	* after acquiring the zrl lock at least one slot was allocated.
	*/
	kstat_named_t dnode_hold_free_lock_misses;
	/*
	* Number of times dnode_hold(..., DNODE_MUST_BE_FREE) needed
	* to retry acquiring slot zrl locks due to contention.
	*/
	kstat_named_t dnode_hold_free_lock_retry;
	/*
	* Number of times dnode_hold(..., DNODE_MUST_BE_FREE) requested
	* a range of dnode slots which were held by another thread.
	*/
	kstat_named_t dnode_hold_free_refcount;
	/*
	* Number of times dnode_hold(..., DNODE_MUST_BE_FREE) requested
	* a range of dnode slots which would overflow the dnode_phys_t.
	*/
	kstat_named_t dnode_hold_free_overflow;
	/*
	* Number of times dnode_free_interior_slots() needed to retry
	* acquiring a slot zrl lock due to contention.
	*/
	kstat_named_t dnode_free_interior_lock_retry;
	/*
	* Number of new dnodes allocated by dnode_allocate().
	*/
	kstat_named_t dnode_allocate;
	/*
	* Number of dnodes re-allocated by dnode_reallocate().
	*/
	kstat_named_t dnode_reallocate;
	/*
	* Number of meta dnode dbufs evicted.
	*/
	kstat_named_t dnode_buf_evict;
	/*
	* Number of times dmu_object_alloc*() reached the end of the existing
	* object ID chunk and advanced to a new one.
	*/
	kstat_named_t dnode_alloc_next_chunk;
	/*
	* Number of times multiple threads attempted to allocate a dnode
	* from the same block of free dnodes.
	*/
	kstat_named_t dnode_alloc_race;
	/*
	* Number of times dmu_object_alloc*() was forced to advance to the
	* next meta dnode dbuf due to an error from dmu_object_next().
	*/
	kstat_named_t dnode_alloc_next_block;
	/*
	* Statistics for tracking dnodes which have been moved.
	*/
	kstat_named_t dnode_move_invalid;
	kstat_named_t dnode_move_recheck1;
	kstat_named_t dnode_move_recheck2;
	kstat_named_t dnode_move_special;
	kstat_named_t dnode_move_handle;
	kstat_named_t dnode_move_rwlock;
	kstat_named_t dnode_move_active;
	} dnode_stats_t;

	extern dnode_stats_t dnode_stats;

	#define DNODE_STAT_INCR(stat, val) \
	atomic_add_64(&dnode_stats.stat.value.ui64, (val));
	#define DNODE_STAT_BUMP(stat) \
	DNODE_STAT_INCR(stat, 1);

	#ifdef ZFS_DEBUG

	#define dprintf_dnode(dn, fmt, ...) do { \
	if (zfs_flags & ZFS_DEBUG_DPRINTF) { \
	char __db_buf[32]; \
	uint64_t __db_obj = (dn)->dn_object; \
	if (__db_obj == DMU_META_DNODE_OBJECT) \
	(void) strlcpy(__db_buf, "mdn", sizeof (__db_buf)); \
	else \
	(void) snprintf(__db_buf, sizeof (__db_buf), "%lld", \
	(u_longlong_t)__db_obj);\
	dprintf_ds((dn)->dn_objset->os_dsl_dataset, "obj=%s " fmt, \
	__db_buf, __VA_ARGS__); \
	} \
	_NOTE(CONSTCOND) } while (0)

	#define DNODE_VERIFY(dn) dnode_verify(dn)
	#define FREE_VERIFY(db, start, end, tx) free_verify(db, start, end, tx)

	#else

	#define dprintf_dnode(db, fmt, ...)
	#define DNODE_VERIFY(dn)
	#define FREE_VERIFY(db, start, end, tx)

	#endif

	#ifdef __cplusplus
	}
	#endif

	#endif /* _SYS_DNODE_H */
	diff --git a/sys/contrib/openzfs/include/sys/zfs_context.h b/sys/contrib/openzfs/include/sys/zfs_context.h
	index e430d17a5f9b..a6ff94317195 100644
	--- a/sys/contrib/openzfs/include/sys/zfs_context.h
	+++ b/sys/contrib/openzfs/include/sys/zfs_context.h
	@@ -1,787 +1,786 @@
	/*
	* 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_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 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);

	static __inline__ uint32_t
	random_in_range(uint32_t range)
	{
	uint32_t r;

	ASSERT(range != 0);

	if (range == 1)
	return (0);

	(void) random_get_pseudo_bytes((uint8_t *)&r, sizeof (r));

	return (r % range);
	}

	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/include/sys/zstd/zstd.h b/sys/contrib/openzfs/include/sys/zstd/zstd.h
	index e87dda1b18d1..ca32a7464556 100644
	--- a/sys/contrib/openzfs/include/sys/zstd/zstd.h
	+++ b/sys/contrib/openzfs/include/sys/zstd/zstd.h
	@@ -1,227 +1,229 @@
	/*
	* 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.
	*/

	#ifndef _ZFS_ZSTD_H
	#define _ZFS_ZSTD_H

	#ifdef __cplusplus
	extern "C" {
	#endif

	/*
	* ZSTD block header
	* NOTE: all fields in this header are in big endian order.
	*/
	typedef struct zfs_zstd_header {
	/* Compressed size of data */
	uint32_t c_len;

	/*
	* Version and compression level
	* We used to use a union to reference compression level
	* and version easily, but as it turns out, relying on the
	* ordering of bitfields is not remotely portable.
	* So now we have get/set functions in zfs_zstd.c for
	* manipulating this in just the right way forever.
	*/
	uint32_t raw_version_level;
	char data[];
	} zfs_zstdhdr_t;

	/*
	* Simple struct to pass the data from raw_version_level around.
	*/
	typedef struct zfs_zstd_meta {
	uint8_t level;
	uint32_t version;
	} zfs_zstdmeta_t;

	/*
	* kstat helper macros
	*/
	#define ZSTDSTAT(stat) (zstd_stats.stat.value.ui64)
	#define ZSTDSTAT_ADD(stat, val) \
	atomic_add_64(&zstd_stats.stat.value.ui64, (val))
	#define ZSTDSTAT_SUB(stat, val) \
	atomic_sub_64(&zstd_stats.stat.value.ui64, (val))
	#define ZSTDSTAT_BUMP(stat) ZSTDSTAT_ADD(stat, 1)

	/* (de)init for user space / kernel emulation */
	int zstd_init(void);
	void zstd_fini(void);

	size_t zfs_zstd_compress(void s_start, void d_start, size_t s_len,
	size_t d_len, int level);
	int zfs_zstd_get_level(void s_start, size_t s_len, uint8_t level);
	int zfs_zstd_decompress_level(void s_start, void d_start, size_t s_len,
	size_t d_len, uint8_t *level);
	int zfs_zstd_decompress(void s_start, void d_start, size_t s_len,
	size_t d_len, int n);
	void zfs_zstd_cache_reap_now(void);

	/*
	* So, the reason we have all these complicated set/get functions is that
	* originally, in the zstd "header" we wrote out to disk, we used a 32-bit
	* bitfield to store the "level" (8 bits) and "version" (24 bits).
	*
	* Unfortunately, bitfields make few promises about how they're arranged in
	* memory...
	*
	* By way of example, if we were using version 1.4.5 and level 3, it'd be
	* level = 0x03, version = 10405/0x0028A5, which gets broken into Vhigh = 0x00,
	* Vmid = 0x28, Vlow = 0xA5. We include these positions below to help follow
	* which data winds up where.
	*
	* As a consequence, we wound up with little endian platforms with a layout
	* like this in memory:
	*
	* 0 8 16 24 32
	* +-------+-------+-------+-------+
	* \| Vlow \| Vmid \| Vhigh \| level \|
	* +-------+-------+-------+-------+
	* =A5 =28 =00 =03
	*
	* ...and then, after being run through BE_32(), serializing this out to
	* disk:
	*
	* 0 8 16 24 32
	* +-------+-------+-------+-------+
	* \| level \| Vhigh \| Vmid \| Vlow \|
	* +-------+-------+-------+-------+
	* =03 =00 =28 =A5
	*
	* while on big-endian systems, since BE_32() is a noop there, both in
	* memory and on disk, we wind up with:
	*
	* 0 8 16 24 32
	* +-------+-------+-------+-------+
	* \| Vhigh \| Vmid \| Vlow \| level \|
	* +-------+-------+-------+-------+
	* =00 =28 =A5 =03
	*
	* (Vhigh is always 0 until version exceeds 6.55.35. Vmid and Vlow are the
	* other two bytes of the "version" data.)
	*
	* So now we use the BF32_SET macros to get consistent behavior (the
	* ondisk LE encoding, since x86 currently rules the world) across
	* platforms, but the "get" behavior requires that we check each of the
	* bytes in the aforementioned former-bitfield for 0x00, and from there,
	* we can know which possible layout we're dealing with. (Only the two
	* that have been observed in the wild are illustrated above, but handlers
	* for all 4 positions of 0x00 are implemented.
	*/

	static inline void
	zfs_get_hdrmeta(const zfs_zstdhdr_t blob, zfs_zstdmeta_t res)
	{
	uint32_t raw = blob->raw_version_level;
	uint8_t findme = 0xff;
	int shift;
	for (shift = 0; shift < 4; shift++) {
	findme = BF32_GET(raw, 8*shift, 8);
	if (findme == 0)
	break;
	}
	switch (shift) {
	case 0:
	res->level = BF32_GET(raw, 24, 8);
	res->version = BSWAP_32(raw);
	res->version = BF32_GET(res->version, 8, 24);
	break;
	case 1:
	res->level = BF32_GET(raw, 0, 8);
	res->version = BSWAP_32(raw);
	res->version = BF32_GET(res->version, 0, 24);
	break;
	case 2:
	res->level = BF32_GET(raw, 24, 8);
	res->version = BF32_GET(raw, 0, 24);
	break;
	case 3:
	res->level = BF32_GET(raw, 0, 8);
	res->version = BF32_GET(raw, 8, 24);
	break;
	default:
	res->level = 0;
	res->version = 0;
	break;
	}
	}

	static inline uint8_t
	zfs_get_hdrlevel(const zfs_zstdhdr_t *blob)
	{
	uint8_t level = 0;
	zfs_zstdmeta_t res;
	zfs_get_hdrmeta(blob, &res);
	level = res.level;
	return (level);
	}

	static inline uint32_t
	zfs_get_hdrversion(const zfs_zstdhdr_t *blob)
	{
	uint32_t version = 0;
	zfs_zstdmeta_t res;
	zfs_get_hdrmeta(blob, &res);
	version = res.version;
	return (version);

	}

	static inline void
	zfs_set_hdrversion(zfs_zstdhdr_t *blob, uint32_t version)
	{
	+ /* cppcheck-suppress syntaxError */
	BF32_SET(blob->raw_version_level, 0, 24, version);
	}

	static inline void
	zfs_set_hdrlevel(zfs_zstdhdr_t *blob, uint8_t level)
	{
	+ /* cppcheck-suppress syntaxError */
	BF32_SET(blob->raw_version_level, 24, 8, level);
	}


	#ifdef __cplusplus
	}
	#endif

	#endif /* _ZFS_ZSTD_H */
	diff --git a/sys/contrib/openzfs/lib/libnvpair/libnvpair.abi b/sys/contrib/openzfs/lib/libnvpair/libnvpair.abi
	index 9ce0ca16ebbb..4f961c83667d 100644
	--- a/sys/contrib/openzfs/lib/libnvpair/libnvpair.abi
	+++ b/sys/contrib/openzfs/lib/libnvpair/libnvpair.abi
	@@ -1,3297 +1,3137 @@
	-<abi-corpus architecture='elf-amd-x86_64' soname='libnvpair.so.3'>
	+<abi-corpus version='2.0' architecture='elf-amd-x86_64' soname='libnvpair.so.3'>
	<elf-needed>
	+ <dependency name='libtirpc.so.3'/>
	<dependency name='libc.so.6'/>
	</elf-needed>
	<elf-function-symbols>
	- <elf-symbol name='_fini' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	- <elf-symbol name='_init' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='dump_nvlist' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fnvlist_add_boolean' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fnvlist_add_boolean_array' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fnvlist_add_boolean_value' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fnvlist_add_byte' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fnvlist_add_byte_array' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fnvlist_add_int16' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fnvlist_add_int16_array' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fnvlist_add_int32' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fnvlist_add_int32_array' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fnvlist_add_int64' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fnvlist_add_int64_array' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fnvlist_add_int8' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fnvlist_add_int8_array' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fnvlist_add_nvlist' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fnvlist_add_nvlist_array' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fnvlist_add_nvpair' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fnvlist_add_string' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fnvlist_add_string_array' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fnvlist_add_uint16' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fnvlist_add_uint16_array' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fnvlist_add_uint32' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fnvlist_add_uint32_array' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fnvlist_add_uint64' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fnvlist_add_uint64_array' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fnvlist_add_uint8' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fnvlist_add_uint8_array' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fnvlist_alloc' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fnvlist_dup' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fnvlist_free' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fnvlist_lookup_boolean' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fnvlist_lookup_boolean_array' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fnvlist_lookup_boolean_value' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fnvlist_lookup_byte' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fnvlist_lookup_byte_array' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fnvlist_lookup_int16' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fnvlist_lookup_int16_array' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fnvlist_lookup_int32' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fnvlist_lookup_int32_array' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fnvlist_lookup_int64' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fnvlist_lookup_int64_array' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fnvlist_lookup_int8' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fnvlist_lookup_int8_array' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fnvlist_lookup_nvlist' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fnvlist_lookup_nvpair' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fnvlist_lookup_string' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fnvlist_lookup_uint16' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fnvlist_lookup_uint16_array' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fnvlist_lookup_uint32' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fnvlist_lookup_uint32_array' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fnvlist_lookup_uint64' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fnvlist_lookup_uint64_array' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fnvlist_lookup_uint8' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fnvlist_lookup_uint8_array' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fnvlist_merge' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fnvlist_num_pairs' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fnvlist_pack' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fnvlist_pack_free' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fnvlist_remove' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fnvlist_remove_nvpair' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fnvlist_size' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fnvlist_unpack' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fnvpair_value_boolean_value' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fnvpair_value_byte' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fnvpair_value_int16' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fnvpair_value_int32' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fnvpair_value_int64' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fnvpair_value_int8' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fnvpair_value_nvlist' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fnvpair_value_string' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fnvpair_value_uint16' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fnvpair_value_uint32' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fnvpair_value_uint64' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fnvpair_value_uint8' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='libspl_assertf' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nv_alloc_fini' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nv_alloc_init' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nv_alloc_reset' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_add_boolean' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_add_boolean_array' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_add_boolean_value' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_add_byte' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_add_byte_array' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_add_double' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_add_hrtime' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_add_int16' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_add_int16_array' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_add_int32' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_add_int32_array' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_add_int64' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_add_int64_array' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_add_int8' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_add_int8_array' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_add_nvlist' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_add_nvlist_array' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_add_nvpair' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_add_string' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_add_string_array' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_add_uint16' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_add_uint16_array' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_add_uint32' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_add_uint32_array' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_add_uint64' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_add_uint64_array' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_add_uint8' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_add_uint8_array' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_alloc' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_dup' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_empty' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_exists' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_free' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_lookup_boolean' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_lookup_boolean_array' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_lookup_boolean_value' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_lookup_byte' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_lookup_byte_array' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_lookup_double' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_lookup_hrtime' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_lookup_int16' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_lookup_int16_array' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_lookup_int32' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_lookup_int32_array' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_lookup_int64' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_lookup_int64_array' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_lookup_int8' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_lookup_int8_array' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_lookup_nv_alloc' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_lookup_nvlist' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_lookup_nvlist_array' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_lookup_nvpair' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_lookup_nvpair_embedded_index' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_lookup_pairs' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_lookup_string' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_lookup_string_array' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_lookup_uint16' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_lookup_uint16_array' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_lookup_uint32' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_lookup_uint32_array' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_lookup_uint64' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_lookup_uint64_array' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_lookup_uint8' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_lookup_uint8_array' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_merge' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_next_nvpair' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_nvflag' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_pack' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_prev_nvpair' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_print' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_print_json' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_prt' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_prtctl_alloc' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_prtctl_dofmt' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_prtctl_doindent' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_prtctl_free' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_prtctl_getdest' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_prtctl_setdest' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_prtctl_setfmt' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_prtctl_setindent' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_prtctlop_boolean' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_prtctlop_boolean_array' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_prtctlop_boolean_value' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_prtctlop_byte' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_prtctlop_byte_array' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_prtctlop_double' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_prtctlop_hrtime' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_prtctlop_int16' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_prtctlop_int16_array' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_prtctlop_int32' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_prtctlop_int32_array' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_prtctlop_int64' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_prtctlop_int64_array' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_prtctlop_int8' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_prtctlop_int8_array' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_prtctlop_nvlist' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_prtctlop_nvlist_array' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_prtctlop_string' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_prtctlop_string_array' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_prtctlop_uint16' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_prtctlop_uint16_array' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_prtctlop_uint32' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_prtctlop_uint32_array' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_prtctlop_uint64' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_prtctlop_uint64_array' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_prtctlop_uint8' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_prtctlop_uint8_array' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_remove' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_remove_all' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_remove_nvpair' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_size' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_unpack' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_xalloc' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_xdup' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_xpack' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_xunpack' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvpair_name' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvpair_type' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvpair_type_is_array' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvpair_value_boolean_array' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvpair_value_boolean_value' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvpair_value_byte' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvpair_value_byte_array' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvpair_value_double' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvpair_value_hrtime' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvpair_value_int16' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvpair_value_int16_array' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvpair_value_int32' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvpair_value_int32_array' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvpair_value_int64' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvpair_value_int64_array' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvpair_value_int8' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvpair_value_int8_array' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvpair_value_match' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvpair_value_match_regex' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvpair_value_nvlist' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvpair_value_nvlist_array' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvpair_value_string' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvpair_value_string_array' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvpair_value_uint16' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvpair_value_uint16_array' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvpair_value_uint32' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvpair_value_uint32_array' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvpair_value_uint64' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvpair_value_uint64_array' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvpair_value_uint8' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvpair_value_uint8_array' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	</elf-function-symbols>
	<elf-variable-symbols>
	<elf-symbol name='aok' size='4' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nv_alloc_nosleep' size='8' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nv_alloc_nosleep_def' size='16' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nv_alloc_sleep' size='8' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nv_alloc_sleep_def' size='16' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nv_fixed_ops' size='8' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nv_fixed_ops_def' size='40' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvlist_hashtable_init_size' size='8' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nvpair_max_recursion' size='4' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	</elf-variable-symbols>
	- <abi-instr version='1.0' address-size='64' path='../../module/nvpair/fnvpair.c' language='LANG_C89'>
	+ <abi-instr address-size='64' path='../../module/nvpair/fnvpair.c' language='LANG_C99'>
	<function-decl name='fnvlist_alloc' mangled-name='fnvlist_alloc' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvlist_alloc'>
	<return type-id='5ce45b60'/>
	</function-decl>
	<function-decl name='fnvlist_free' mangled-name='fnvlist_free' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvlist_free'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='fnvlist_size' mangled-name='fnvlist_size' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvlist_size'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<return type-id='b59d7dce'/>
	</function-decl>
	<function-decl name='fnvlist_pack' mangled-name='fnvlist_pack' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvlist_pack'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='78c01427' name='sizep'/>
	<return type-id='26a90f95'/>
	</function-decl>
	<function-decl name='fnvlist_pack_free' mangled-name='fnvlist_pack_free' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvlist_pack_free'>
	<parameter type-id='26a90f95' name='pack'/>
	<parameter type-id='b59d7dce' name='size'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='fnvlist_unpack' mangled-name='fnvlist_unpack' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvlist_unpack'>
	<parameter type-id='26a90f95' name='buf'/>
	<parameter type-id='b59d7dce' name='buflen'/>
	<return type-id='5ce45b60'/>
	</function-decl>
	<function-decl name='fnvlist_dup' mangled-name='fnvlist_dup' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvlist_dup'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<return type-id='5ce45b60'/>
	</function-decl>
	<function-decl name='fnvlist_merge' mangled-name='fnvlist_merge' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvlist_merge'>
	<parameter type-id='5ce45b60' name='dst'/>
	<parameter type-id='5ce45b60' name='src'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='fnvlist_num_pairs' mangled-name='fnvlist_num_pairs' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvlist_num_pairs'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<return type-id='b59d7dce'/>
	</function-decl>
	<function-decl name='fnvlist_add_boolean' mangled-name='fnvlist_add_boolean' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvlist_add_boolean'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='fnvlist_add_boolean_value' mangled-name='fnvlist_add_boolean_value' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvlist_add_boolean_value'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='c19b74c3' name='val'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='fnvlist_add_byte' mangled-name='fnvlist_add_byte' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvlist_add_byte'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='d8bf0010' name='val'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='fnvlist_add_int8' mangled-name='fnvlist_add_int8' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvlist_add_int8'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='ee31ee44' name='val'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='fnvlist_add_uint8' mangled-name='fnvlist_add_uint8' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvlist_add_uint8'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='b96825af' name='val'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='fnvlist_add_int16' mangled-name='fnvlist_add_int16' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvlist_add_int16'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='23bd8cb5' name='val'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='fnvlist_add_uint16' mangled-name='fnvlist_add_uint16' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvlist_add_uint16'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='149c6638' name='val'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='fnvlist_add_int32' mangled-name='fnvlist_add_int32' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvlist_add_int32'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='3ff5601b' name='val'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='fnvlist_add_uint32' mangled-name='fnvlist_add_uint32' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvlist_add_uint32'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='8f92235e' name='val'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='fnvlist_add_int64' mangled-name='fnvlist_add_int64' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvlist_add_int64'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='9da381c4' name='val'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='fnvlist_add_uint64' mangled-name='fnvlist_add_uint64' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvlist_add_uint64'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='9c313c2d' name='val'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='fnvlist_add_string' mangled-name='fnvlist_add_string' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvlist_add_string'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='80f4b756' name='val'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='fnvlist_add_nvlist' mangled-name='fnvlist_add_nvlist' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvlist_add_nvlist'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='5ce45b60' name='val'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='fnvlist_add_nvpair' mangled-name='fnvlist_add_nvpair' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvlist_add_nvpair'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='3fa542f0' name='pair'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='fnvlist_add_boolean_array' mangled-name='fnvlist_add_boolean_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvlist_add_boolean_array'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='37e3bd22' name='val'/>
	<parameter type-id='3502e3ff' name='n'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='fnvlist_add_byte_array' mangled-name='fnvlist_add_byte_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvlist_add_byte_array'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='45b65157' name='val'/>
	<parameter type-id='3502e3ff' name='n'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='fnvlist_add_int8_array' mangled-name='fnvlist_add_int8_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvlist_add_int8_array'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='256d5229' name='val'/>
	<parameter type-id='3502e3ff' name='n'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='fnvlist_add_uint8_array' mangled-name='fnvlist_add_uint8_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvlist_add_uint8_array'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='ae3e8ca6' name='val'/>
	<parameter type-id='3502e3ff' name='n'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='fnvlist_add_int16_array' mangled-name='fnvlist_add_int16_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvlist_add_int16_array'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='f76f73d0' name='val'/>
	<parameter type-id='3502e3ff' name='n'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='fnvlist_add_uint16_array' mangled-name='fnvlist_add_uint16_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvlist_add_uint16_array'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='8a121f49' name='val'/>
	<parameter type-id='3502e3ff' name='n'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='fnvlist_add_int32_array' mangled-name='fnvlist_add_int32_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvlist_add_int32_array'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='4aafb922' name='val'/>
	<parameter type-id='3502e3ff' name='n'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='fnvlist_add_uint32_array' mangled-name='fnvlist_add_uint32_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvlist_add_uint32_array'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='90421557' name='val'/>
	<parameter type-id='3502e3ff' name='n'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='fnvlist_add_int64_array' mangled-name='fnvlist_add_int64_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvlist_add_int64_array'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='cb785ebf' name='val'/>
	<parameter type-id='3502e3ff' name='n'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='fnvlist_add_uint64_array' mangled-name='fnvlist_add_uint64_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvlist_add_uint64_array'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='5d6479ae' name='val'/>
	<parameter type-id='3502e3ff' name='n'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='fnvlist_add_string_array' mangled-name='fnvlist_add_string_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvlist_add_string_array'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='f319fae0' name='val'/>
	<parameter type-id='3502e3ff' name='n'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='fnvlist_add_nvlist_array' mangled-name='fnvlist_add_nvlist_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvlist_add_nvlist_array'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='857bb57e' name='val'/>
	<parameter type-id='3502e3ff' name='n'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='fnvlist_remove' mangled-name='fnvlist_remove' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvlist_remove'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='fnvlist_remove_nvpair' mangled-name='fnvlist_remove_nvpair' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvlist_remove_nvpair'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='3fa542f0' name='pair'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='fnvlist_lookup_nvpair' mangled-name='fnvlist_lookup_nvpair' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvlist_lookup_nvpair'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<return type-id='3fa542f0'/>
	</function-decl>
	<function-decl name='fnvlist_lookup_boolean' mangled-name='fnvlist_lookup_boolean' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvlist_lookup_boolean'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<return type-id='c19b74c3'/>
	</function-decl>
	<function-decl name='fnvlist_lookup_boolean_value' mangled-name='fnvlist_lookup_boolean_value' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvlist_lookup_boolean_value'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<return type-id='c19b74c3'/>
	</function-decl>
	<function-decl name='fnvlist_lookup_byte' mangled-name='fnvlist_lookup_byte' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvlist_lookup_byte'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<return type-id='d8bf0010'/>
	</function-decl>
	<function-decl name='fnvlist_lookup_int8' mangled-name='fnvlist_lookup_int8' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvlist_lookup_int8'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<return type-id='ee31ee44'/>
	</function-decl>
	<function-decl name='fnvlist_lookup_int16' mangled-name='fnvlist_lookup_int16' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvlist_lookup_int16'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<return type-id='23bd8cb5'/>
	</function-decl>
	<function-decl name='fnvlist_lookup_int32' mangled-name='fnvlist_lookup_int32' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvlist_lookup_int32'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<return type-id='3ff5601b'/>
	</function-decl>
	<function-decl name='fnvlist_lookup_int64' mangled-name='fnvlist_lookup_int64' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvlist_lookup_int64'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<return type-id='9da381c4'/>
	</function-decl>
	<function-decl name='fnvlist_lookup_uint8' mangled-name='fnvlist_lookup_uint8' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvlist_lookup_uint8'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<return type-id='b96825af'/>
	</function-decl>
	<function-decl name='fnvlist_lookup_uint16' mangled-name='fnvlist_lookup_uint16' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvlist_lookup_uint16'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<return type-id='149c6638'/>
	</function-decl>
	<function-decl name='fnvlist_lookup_uint32' mangled-name='fnvlist_lookup_uint32' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvlist_lookup_uint32'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<return type-id='8f92235e'/>
	</function-decl>
	<function-decl name='fnvlist_lookup_uint64' mangled-name='fnvlist_lookup_uint64' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvlist_lookup_uint64'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<return type-id='9c313c2d'/>
	</function-decl>
	<function-decl name='fnvlist_lookup_string' mangled-name='fnvlist_lookup_string' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvlist_lookup_string'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<return type-id='26a90f95'/>
	</function-decl>
	<function-decl name='fnvlist_lookup_nvlist' mangled-name='fnvlist_lookup_nvlist' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvlist_lookup_nvlist'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<return type-id='5ce45b60'/>
	</function-decl>
	<function-decl name='fnvlist_lookup_boolean_array' mangled-name='fnvlist_lookup_boolean_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvlist_lookup_boolean_array'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='4dd26a40' name='n'/>
	<return type-id='37e3bd22'/>
	</function-decl>
	<function-decl name='fnvlist_lookup_byte_array' mangled-name='fnvlist_lookup_byte_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvlist_lookup_byte_array'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='4dd26a40' name='n'/>
	<return type-id='45b65157'/>
	</function-decl>
	<function-decl name='fnvlist_lookup_int8_array' mangled-name='fnvlist_lookup_int8_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvlist_lookup_int8_array'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='4dd26a40' name='n'/>
	<return type-id='256d5229'/>
	</function-decl>
	<function-decl name='fnvlist_lookup_uint8_array' mangled-name='fnvlist_lookup_uint8_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvlist_lookup_uint8_array'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='4dd26a40' name='n'/>
	<return type-id='ae3e8ca6'/>
	</function-decl>
	<function-decl name='fnvlist_lookup_int16_array' mangled-name='fnvlist_lookup_int16_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvlist_lookup_int16_array'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='4dd26a40' name='n'/>
	<return type-id='f76f73d0'/>
	</function-decl>
	<function-decl name='fnvlist_lookup_uint16_array' mangled-name='fnvlist_lookup_uint16_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvlist_lookup_uint16_array'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='4dd26a40' name='n'/>
	<return type-id='8a121f49'/>
	</function-decl>
	<function-decl name='fnvlist_lookup_int32_array' mangled-name='fnvlist_lookup_int32_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvlist_lookup_int32_array'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='4dd26a40' name='n'/>
	<return type-id='4aafb922'/>
	</function-decl>
	<function-decl name='fnvlist_lookup_uint32_array' mangled-name='fnvlist_lookup_uint32_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvlist_lookup_uint32_array'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='4dd26a40' name='n'/>
	<return type-id='90421557'/>
	</function-decl>
	<function-decl name='fnvlist_lookup_int64_array' mangled-name='fnvlist_lookup_int64_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvlist_lookup_int64_array'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='4dd26a40' name='n'/>
	<return type-id='cb785ebf'/>
	</function-decl>
	<function-decl name='fnvlist_lookup_uint64_array' mangled-name='fnvlist_lookup_uint64_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvlist_lookup_uint64_array'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='4dd26a40' name='n'/>
	<return type-id='5d6479ae'/>
	</function-decl>
	- <pointer-type-def type-id='c19b74c3' size-in-bits='64' id='37e3bd22'/>
	- <pointer-type-def type-id='a84c031d' size-in-bits='64' id='26a90f95'/>
	- <pointer-type-def type-id='57de658a' size-in-bits='64' id='f319fae0'/>
	- <pointer-type-def type-id='9b45d938' size-in-bits='64' id='80f4b756'/>
	- <pointer-type-def type-id='23bd8cb5' size-in-bits='64' id='f76f73d0'/>
	- <pointer-type-def type-id='3ff5601b' size-in-bits='64' id='4aafb922'/>
	- <pointer-type-def type-id='9da381c4' size-in-bits='64' id='cb785ebf'/>
	- <pointer-type-def type-id='ee31ee44' size-in-bits='64' id='256d5229'/>
	- <pointer-type-def type-id='8e8d4be3' size-in-bits='64' id='5ce45b60'/>
	- <pointer-type-def type-id='5ce45b60' size-in-bits='64' id='857bb57e'/>
	- <pointer-type-def type-id='57928edf' size-in-bits='64' id='3fa542f0'/>
	- <pointer-type-def type-id='b59d7dce' size-in-bits='64' id='78c01427'/>
	- <typedef-decl name='boolean_t' type-id='08f5ca17' id='c19b74c3'/>
	- <typedef-decl name='int16_t' type-id='a2185560' id='23bd8cb5'/>
	- <typedef-decl name='int32_t' type-id='95e97e5e' id='3ff5601b'/>
	- <typedef-decl name='int64_t' type-id='bd54fe1a' id='9da381c4'/>
	- <typedef-decl name='int8_t' type-id='28577a57' id='ee31ee44'/>
	- <typedef-decl name='size_t' type-id='7359adad' id='b59d7dce'/>
	- <typedef-decl name='uchar_t' type-id='002ac4a6' id='d8bf0010'/>
	- <typedef-decl name='uint16_t' type-id='8efea9e5' id='149c6638'/>
	- <typedef-decl name='uint32_t' type-id='f0981eeb' id='8f92235e'/>
	- <typedef-decl name='uint64_t' type-id='7359adad' id='9c313c2d'/>
	- <typedef-decl name='uint8_t' type-id='002ac4a6' id='b96825af'/>
	- <typedef-decl name='uint_t' type-id='f0981eeb' id='3502e3ff'/>
	- <pointer-type-def type-id='d8bf0010' size-in-bits='64' id='45b65157'/>
	- <pointer-type-def type-id='149c6638' size-in-bits='64' id='8a121f49'/>
	- <pointer-type-def type-id='8f92235e' size-in-bits='64' id='90421557'/>
	- <pointer-type-def type-id='9c313c2d' size-in-bits='64' id='5d6479ae'/>
	- <pointer-type-def type-id='b96825af' size-in-bits='64' id='ae3e8ca6'/>
	- <pointer-type-def type-id='3502e3ff' size-in-bits='64' id='4dd26a40'/>
	- <type-decl name='void' id='48b5725f'/>
	- <type-decl name='char' size-in-bits='8' id='a84c031d'/>
	- <qualified-type-def type-id='26a90f95' const='yes' id='57de658a'/>
	- <qualified-type-def type-id='a84c031d' const='yes' id='9b45d938'/>
	- <enum-decl name='__anonymous_enum__' is-anonymous='yes' id='08f5ca17'>
	- <underlying-type type-id='9cac1fee'/>
	- <enumerator name='B_FALSE' value='0'/>
	- <enumerator name='B_TRUE' value='1'/>
	- </enum-decl>
	- <type-decl name='int' size-in-bits='32' id='95e97e5e'/>
	- <type-decl name='long int' size-in-bits='64' id='bd54fe1a'/>
	- <type-decl name='short int' size-in-bits='16' id='a2185560'/>
	- <type-decl name='signed char' size-in-bits='8' id='28577a57'/>
	- <typedef-decl name='nvlist_t' type-id='ac266fd9' id='8e8d4be3'/>
	- <typedef-decl name='nvpair_t' type-id='1c34e459' id='57928edf'/>
	- <type-decl name='unsigned char' size-in-bits='8' id='002ac4a6'/>
	- <type-decl name='unsigned int' size-in-bits='32' id='f0981eeb'/>
	- <type-decl name='unsigned long int' size-in-bits='64' id='7359adad'/>
	- <type-decl name='unsigned short int' size-in-bits='16' id='8efea9e5'/>
	- <class-decl name='nvlist' size-in-bits='192' is-struct='yes' visibility='default' id='ac266fd9'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='nvl_version' type-id='3ff5601b' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='32'>
	- <var-decl name='nvl_nvflag' type-id='8f92235e' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='nvl_priv' type-id='9c313c2d' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='nvl_flag' type-id='8f92235e' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='160'>
	- <var-decl name='nvl_pad' type-id='3ff5601b' visibility='default'/>
	- </data-member>
	- </class-decl>
	- <class-decl name='nvpair' size-in-bits='128' is-struct='yes' visibility='default' id='1c34e459'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='nvp_size' type-id='3ff5601b' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='32'>
	- <var-decl name='nvp_name_sz' type-id='23bd8cb5' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='48'>
	- <var-decl name='nvp_reserve' type-id='23bd8cb5' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='nvp_value_elem' type-id='3ff5601b' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='96'>
	- <var-decl name='nvp_type' type-id='8d0687d2' visibility='default'/>
	- </data-member>
	- </class-decl>
	- <typedef-decl name='data_type_t' type-id='40ed39d2' id='8d0687d2'/>
	- <enum-decl name='__anonymous_enum__1' is-anonymous='yes' id='40ed39d2'>
	+ </abi-instr>
	+ <abi-instr address-size='64' path='../../module/nvpair/nvpair.c' language='LANG_C99'>
	+ <typedef-decl name='__u_short' type-id='8efea9e5' id='46c660f8'/>
	+ <typedef-decl name='__u_int' type-id='f0981eeb' id='8ae6822f'/>
	+ <typedef-decl name='__quad_t' type-id='bd54fe1a' id='2632227a'/>
	+ <typedef-decl name='__u_quad_t' type-id='7359adad' id='5f3d50a6'/>
	+ <typedef-decl name='u_short' type-id='46c660f8' id='32580e96'/>
	+ <typedef-decl name='u_int' type-id='8ae6822f' id='48f7c3f5'/>
	+ <typedef-decl name='quad_t' type-id='2632227a' id='f5ef0660'/>
	+ <typedef-decl name='u_quad_t' type-id='5f3d50a6' id='bd226ac0'/>
	+ <typedef-decl name='bool_t' type-id='3ff5601b' id='310a70df'/>
	+ <enum-decl name='xdr_op' id='6badf1b8'>
	<underlying-type type-id='9cac1fee'/>
	- <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'/>
	+ <enumerator name='XDR_ENCODE' value='0'/>
	+ <enumerator name='XDR_DECODE' value='1'/>
	+ <enumerator name='XDR_FREE' value='2'/>
	</enum-decl>
	- </abi-instr>
	- <abi-instr version='1.0' address-size='64' path='../../module/nvpair/nvpair.c' language='LANG_C89'>
	- <typedef-decl name='bool_t' type-id='95e97e5e' id='310a70df'/>
	- <class-decl name='XDR' size-in-bits='384' is-struct='yes' visibility='default' id='a8981939'>
	+ <class-decl name='__rpc_xdr' size-in-bits='384' is-struct='yes' visibility='default' id='755707df'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='x_op' type-id='6badf1b8' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='x_ops' type-id='b6da5f20' visibility='default'/>
	+ <var-decl name='x_ops' type-id='3457e9c5' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='x_public' type-id='02f26d81' visibility='default'/>
	+ <var-decl name='x_public' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	- <var-decl name='x_private' type-id='02f26d81' visibility='default'/>
	+ <var-decl name='x_private' type-id='eaa32e2f' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='256'>
	- <var-decl name='x_base' type-id='02f26d81' visibility='default'/>
	+ <var-decl name='x_base' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='320'>
	<var-decl name='x_handy' type-id='48f7c3f5' visibility='default'/>
	</data-member>
	</class-decl>
	- <enum-decl name='xdr_op' id='6badf1b8'>
	- <underlying-type type-id='9cac1fee'/>
	- <enumerator name='XDR_ENCODE' value='0'/>
	- <enumerator name='XDR_DECODE' value='1'/>
	- <enumerator name='XDR_FREE' value='2'/>
	- </enum-decl>
	- <class-decl name='xdr_ops' size-in-bits='640' is-struct='yes' visibility='default' id='ea1474f2'>
	+ <class-decl name='xdr_ops' size-in-bits='576' is-struct='yes' visibility='default' id='ea1474f2'>
	<data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='x_getlong' type-id='fbb56359' visibility='default'/>
	+ <var-decl name='x_getlong' type-id='a4e6dd3f' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='x_putlong' type-id='dede35ae' visibility='default'/>
	+ <var-decl name='x_putlong' type-id='d447b08c' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='x_getbytes' type-id='6c71ad0c' visibility='default'/>
	+ <var-decl name='x_getbytes' type-id='b0b6ccaa' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	- <var-decl name='x_putbytes' type-id='da8c6031' visibility='default'/>
	+ <var-decl name='x_putbytes' type-id='581c24b7' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='256'>
	- <var-decl name='x_getpostn' type-id='854d8f1f' visibility='default'/>
	+ <var-decl name='x_getpostn' type-id='1c77bdb0' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='320'>
	- <var-decl name='x_setpostn' type-id='f20049b8' visibility='default'/>
	+ <var-decl name='x_setpostn' type-id='13fdb43e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='384'>
	- <var-decl name='x_inline' type-id='b5750a7f' visibility='default'/>
	+ <var-decl name='x_inline' type-id='788e1f25' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='448'>
	- <var-decl name='x_destroy' type-id='83759e74' visibility='default'/>
	+ <var-decl name='x_destroy' type-id='d781e3b2' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='512'>
	- <var-decl name='x_getint32' type-id='4d7c51b3' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='576'>
	- <var-decl name='x_putint32' type-id='282b021e' visibility='default'/>
	+ <var-decl name='x_control' type-id='733fc725' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='XDR' type-id='a8981939' id='bc407f0e'/>
	- <typedef-decl name='caddr_t' type-id='5e5c3347' id='02f26d81'/>
	- <typedef-decl name='__caddr_t' type-id='26a90f95' id='5e5c3347'/>
	- <typedef-decl name='u_int' type-id='8ae6822f' id='48f7c3f5'/>
	- <typedef-decl name='__u_int' type-id='f0981eeb' id='8ae6822f'/>
	- <typedef-decl name='u_short' type-id='46c660f8' id='32580e96'/>
	- <typedef-decl name='__u_short' type-id='8efea9e5' id='46c660f8'/>
	- <typedef-decl name='quad_t' type-id='2632227a' id='f5ef0660'/>
	- <typedef-decl name='__quad_t' type-id='bd54fe1a' id='2632227a'/>
	- <typedef-decl name='u_quad_t' type-id='5f3d50a6' id='bd226ac0'/>
	- <typedef-decl name='__u_quad_t' type-id='7359adad' id='5f3d50a6'/>
	- <typedef-decl name='xdrproc_t' type-id='c908e93a' id='c28db3e9'/>
	+ <typedef-decl name='XDR' type-id='755707df' id='bc407f0e'/>
	+ <typedef-decl name='xdrproc_t' type-id='94d188f0' id='c28db3e9'/>
	<pointer-type-def type-id='bc407f0e' size-in-bits='64' id='17fd1621'/>
	- <pointer-type-def type-id='02f26d81' size-in-bits='64' id='c0ad6580'/>
	+ <pointer-type-def type-id='755707df' size-in-bits='64' id='812c6697'/>
	<qualified-type-def type-id='26a90f95' const='yes' id='57de658a'/>
	<pointer-type-def type-id='57de658a' size-in-bits='64' id='f319fae0'/>
	- <qualified-type-def type-id='bc407f0e' const='yes' id='348836be'/>
	- <pointer-type-def type-id='348836be' size-in-bits='64' id='466deafc'/>
	- <qualified-type-def type-id='02f26d81' const='yes' id='1d276ed1'/>
	- <qualified-type-def type-id='3ff5601b' const='yes' id='922df12b'/>
	- <pointer-type-def type-id='922df12b' size-in-bits='64' id='1f526493'/>
	+ <qualified-type-def type-id='9b23c9ad' restrict='yes' id='8c85230f'/>
	<qualified-type-def type-id='bd54fe1a' const='yes' id='9cb2385f'/>
	<pointer-type-def type-id='9cb2385f' size-in-bits='64' id='218ee02f'/>
	+ <qualified-type-def type-id='ea1474f2' const='yes' id='485ede6d'/>
	+ <pointer-type-def type-id='485ede6d' size-in-bits='64' id='3457e9c5'/>
	<pointer-type-def type-id='95e97e5e' size-in-bits='64' id='7292109c'/>
	- <pointer-type-def type-id='187fc00b' size-in-bits='64' id='b5750a7f'/>
	+ <pointer-type-def type-id='441e0c31' size-in-bits='64' id='788e1f25'/>
	<pointer-type-def type-id='bd54fe1a' size-in-bits='64' id='3ccc2590'/>
	<pointer-type-def type-id='3fa542f0' size-in-bits='64' id='0b283d2e'/>
	<pointer-type-def type-id='f5ef0660' size-in-bits='64' id='de23782d'/>
	<pointer-type-def type-id='a2185560' size-in-bits='64' id='764e437e'/>
	<pointer-type-def type-id='b59d7dce' size-in-bits='64' id='78c01427'/>
	- <pointer-type-def type-id='35084435' size-in-bits='64' id='da8c6031'/>
	- <pointer-type-def type-id='e9c79c04' size-in-bits='64' id='282b021e'/>
	- <pointer-type-def type-id='6b57892c' size-in-bits='64' id='dede35ae'/>
	- <pointer-type-def type-id='68c52617' size-in-bits='64' id='4d7c51b3'/>
	- <pointer-type-def type-id='4b63097d' size-in-bits='64' id='fbb56359'/>
	- <pointer-type-def type-id='cb15e1d2' size-in-bits='64' id='6c71ad0c'/>
	- <pointer-type-def type-id='54decd9e' size-in-bits='64' id='f20049b8'/>
	- <pointer-type-def type-id='3c81bd20' size-in-bits='64' id='c908e93a'/>
	- <pointer-type-def type-id='74c0842b' size-in-bits='64' id='854d8f1f'/>
	+ <pointer-type-def type-id='e80b47fe' size-in-bits='64' id='94d188f0'/>
	+ <pointer-type-def type-id='1c7a4858' size-in-bits='64' id='b0b6ccaa'/>
	+ <pointer-type-def type-id='f6358b93' size-in-bits='64' id='581c24b7'/>
	+ <pointer-type-def type-id='45354e42' size-in-bits='64' id='d447b08c'/>
	+ <pointer-type-def type-id='0760d6d1' size-in-bits='64' id='733fc725'/>
	+ <pointer-type-def type-id='be0f9e0b' size-in-bits='64' id='a4e6dd3f'/>
	+ <pointer-type-def type-id='16eb5704' size-in-bits='64' id='13fdb43e'/>
	+ <pointer-type-def type-id='46870456' size-in-bits='64' id='1c77bdb0'/>
	<pointer-type-def type-id='48f7c3f5' size-in-bits='64' id='b4c2e924'/>
	<pointer-type-def type-id='bd226ac0' size-in-bits='64' id='fce59795'/>
	<pointer-type-def type-id='32580e96' size-in-bits='64' id='ede2c2f5'/>
	- <pointer-type-def type-id='9314f532' size-in-bits='64' id='83759e74'/>
	- <pointer-type-def type-id='ea1474f2' size-in-bits='64' id='b6da5f20'/>
	+ <pointer-type-def type-id='c87cb1d0' size-in-bits='64' id='d781e3b2'/>
	+ <var-decl name='nvpair_max_recursion' type-id='95e97e5e' mangled-name='nvpair_max_recursion' visibility='default' elf-symbol-id='nvpair_max_recursion'/>
	+ <var-decl name='nvlist_hashtable_init_size' type-id='9c313c2d' mangled-name='nvlist_hashtable_init_size' visibility='default' elf-symbol-id='nvlist_hashtable_init_size'/>
	<function-decl name='nv_alloc_init' mangled-name='nv_alloc_init' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nv_alloc_init'>
	<parameter type-id='11871392' name='nva'/>
	<parameter type-id='ee1d4944' name='nvo'/>
	<parameter is-variadic='yes'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='nv_alloc_reset' mangled-name='nv_alloc_reset' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nv_alloc_reset'>
	<parameter type-id='11871392' name='nva'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='nv_alloc_fini' mangled-name='nv_alloc_fini' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nv_alloc_fini'>
	<parameter type-id='11871392' name='nva'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='nvlist_lookup_nv_alloc' mangled-name='nvlist_lookup_nv_alloc' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_lookup_nv_alloc'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<return type-id='11871392'/>
	</function-decl>
	<function-decl name='nvlist_nvflag' mangled-name='nvlist_nvflag' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_nvflag'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<return type-id='3502e3ff'/>
	</function-decl>
	- <function-decl name='nvlist_xalloc' mangled-name='nvlist_xalloc' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_xalloc'>
	+ <function-decl name='nvlist_alloc' mangled-name='nvlist_alloc' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_alloc'>
	<parameter type-id='857bb57e' name='nvlp'/>
	<parameter type-id='3502e3ff' name='nvflag'/>
	- <parameter type-id='11871392' name='nva'/>
	+ <parameter type-id='95e97e5e' name='kmflag'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='nvlist_alloc' mangled-name='nvlist_alloc' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_alloc'>
	+ <function-decl name='nvlist_xalloc' mangled-name='nvlist_xalloc' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_xalloc'>
	<parameter type-id='857bb57e' name='nvlp'/>
	<parameter type-id='3502e3ff' name='nvflag'/>
	- <parameter type-id='95e97e5e' name='kmflag'/>
	+ <parameter type-id='11871392' name='nva'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='nvlist_free' mangled-name='nvlist_free' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_free'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='nvlist_remove_nvpair' mangled-name='nvlist_remove_nvpair' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_remove_nvpair'>
	+ <function-decl name='nvlist_dup' mangled-name='nvlist_dup' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_dup'>
	<parameter type-id='5ce45b60' name='nvl'/>
	- <parameter type-id='3fa542f0' name='nvp'/>
	+ <parameter type-id='857bb57e' name='nvlp'/>
	+ <parameter type-id='95e97e5e' name='kmflag'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='nvlist_xdup' mangled-name='nvlist_xdup' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_xdup'>
	+ <parameter type-id='5ce45b60' name='nvl'/>
	+ <parameter type-id='857bb57e' name='nvlp'/>
	+ <parameter type-id='11871392' name='nva'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='nvlist_remove_all' mangled-name='nvlist_remove_all' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_remove_all'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='nvlist_remove' mangled-name='nvlist_remove' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_remove'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='8d0687d2' name='type'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='nvlist_xdup' mangled-name='nvlist_xdup' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_xdup'>
	- <parameter type-id='5ce45b60' name='nvl'/>
	- <parameter type-id='857bb57e' name='nvlp'/>
	- <parameter type-id='11871392' name='nva'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='nvlist_dup' mangled-name='nvlist_dup' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_dup'>
	+ <function-decl name='nvlist_remove_nvpair' mangled-name='nvlist_remove_nvpair' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_remove_nvpair'>
	<parameter type-id='5ce45b60' name='nvl'/>
	- <parameter type-id='857bb57e' name='nvlp'/>
	- <parameter type-id='95e97e5e' name='kmflag'/>
	+ <parameter type-id='3fa542f0' name='nvp'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='nvlist_add_boolean' mangled-name='nvlist_add_boolean' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_add_boolean'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='nvlist_add_boolean_value' mangled-name='nvlist_add_boolean_value' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_add_boolean_value'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='c19b74c3' name='val'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='nvlist_add_byte' mangled-name='nvlist_add_byte' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_add_byte'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='d8bf0010' name='val'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='nvlist_add_int8' mangled-name='nvlist_add_int8' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_add_int8'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='ee31ee44' name='val'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='nvlist_add_uint8' mangled-name='nvlist_add_uint8' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_add_uint8'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='b96825af' name='val'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='nvlist_add_int16' mangled-name='nvlist_add_int16' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_add_int16'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='23bd8cb5' name='val'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='nvlist_add_uint16' mangled-name='nvlist_add_uint16' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_add_uint16'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='149c6638' name='val'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='nvlist_add_int32' mangled-name='nvlist_add_int32' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_add_int32'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='3ff5601b' name='val'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='nvlist_add_uint32' mangled-name='nvlist_add_uint32' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_add_uint32'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='8f92235e' name='val'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='nvlist_add_int64' mangled-name='nvlist_add_int64' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_add_int64'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='9da381c4' name='val'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='nvlist_add_uint64' mangled-name='nvlist_add_uint64' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_add_uint64'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='9c313c2d' name='val'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='nvlist_add_double' mangled-name='nvlist_add_double' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_add_double'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='a0eb0f08' name='val'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='nvlist_add_string' mangled-name='nvlist_add_string' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_add_string'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='80f4b756' name='val'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='nvlist_add_boolean_array' mangled-name='nvlist_add_boolean_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_add_boolean_array'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='37e3bd22' name='a'/>
	<parameter type-id='3502e3ff' name='n'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='nvlist_add_byte_array' mangled-name='nvlist_add_byte_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_add_byte_array'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='45b65157' name='a'/>
	<parameter type-id='3502e3ff' name='n'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='nvlist_add_int8_array' mangled-name='nvlist_add_int8_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_add_int8_array'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='256d5229' name='a'/>
	<parameter type-id='3502e3ff' name='n'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='nvlist_add_uint8_array' mangled-name='nvlist_add_uint8_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_add_uint8_array'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='ae3e8ca6' name='a'/>
	<parameter type-id='3502e3ff' name='n'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='nvlist_add_int16_array' mangled-name='nvlist_add_int16_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_add_int16_array'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='f76f73d0' name='a'/>
	<parameter type-id='3502e3ff' name='n'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='nvlist_add_uint16_array' mangled-name='nvlist_add_uint16_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_add_uint16_array'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='8a121f49' name='a'/>
	<parameter type-id='3502e3ff' name='n'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='nvlist_add_int32_array' mangled-name='nvlist_add_int32_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_add_int32_array'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='4aafb922' name='a'/>
	<parameter type-id='3502e3ff' name='n'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='nvlist_add_uint32_array' mangled-name='nvlist_add_uint32_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_add_uint32_array'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='90421557' name='a'/>
	<parameter type-id='3502e3ff' name='n'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='nvlist_add_int64_array' mangled-name='nvlist_add_int64_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_add_int64_array'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='cb785ebf' name='a'/>
	<parameter type-id='3502e3ff' name='n'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='nvlist_add_uint64_array' mangled-name='nvlist_add_uint64_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_add_uint64_array'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='5d6479ae' name='a'/>
	<parameter type-id='3502e3ff' name='n'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='nvlist_add_string_array' mangled-name='nvlist_add_string_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_add_string_array'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='f319fae0' name='a'/>
	<parameter type-id='3502e3ff' name='n'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='nvlist_add_hrtime' mangled-name='nvlist_add_hrtime' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_add_hrtime'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='cebdd548' name='val'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='nvlist_add_nvlist' mangled-name='nvlist_add_nvlist' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_add_nvlist'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='5ce45b60' name='val'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='nvlist_add_nvlist_array' mangled-name='nvlist_add_nvlist_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_add_nvlist_array'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='857bb57e' name='a'/>
	<parameter type-id='3502e3ff' name='n'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='nvlist_prev_nvpair' mangled-name='nvlist_prev_nvpair' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_prev_nvpair'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='3fa542f0' name='nvp'/>
	<return type-id='3fa542f0'/>
	</function-decl>
	<function-decl name='nvlist_empty' mangled-name='nvlist_empty' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_empty'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<return type-id='c19b74c3'/>
	</function-decl>
	<function-decl name='nvlist_lookup_boolean' mangled-name='nvlist_lookup_boolean' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_lookup_boolean'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='nvlist_lookup_boolean_value' mangled-name='nvlist_lookup_boolean_value' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_lookup_boolean_value'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='37e3bd22' name='val'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='nvlist_lookup_byte' mangled-name='nvlist_lookup_byte' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_lookup_byte'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='45b65157' name='val'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='nvlist_lookup_int8' mangled-name='nvlist_lookup_int8' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_lookup_int8'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='256d5229' name='val'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='nvlist_lookup_uint8' mangled-name='nvlist_lookup_uint8' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_lookup_uint8'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='ae3e8ca6' name='val'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='nvlist_lookup_int16' mangled-name='nvlist_lookup_int16' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_lookup_int16'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='f76f73d0' name='val'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='nvlist_lookup_uint16' mangled-name='nvlist_lookup_uint16' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_lookup_uint16'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='8a121f49' name='val'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='nvlist_lookup_int32' mangled-name='nvlist_lookup_int32' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_lookup_int32'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='4aafb922' name='val'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='nvlist_lookup_uint32' mangled-name='nvlist_lookup_uint32' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_lookup_uint32'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='90421557' name='val'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='nvlist_lookup_int64' mangled-name='nvlist_lookup_int64' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_lookup_int64'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='cb785ebf' name='val'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='nvlist_lookup_uint64' mangled-name='nvlist_lookup_uint64' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_lookup_uint64'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='5d6479ae' name='val'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='nvlist_lookup_double' mangled-name='nvlist_lookup_double' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_lookup_double'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='7408d286' name='val'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='nvlist_lookup_string' mangled-name='nvlist_lookup_string' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_lookup_string'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='9b23c9ad' name='val'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='nvlist_lookup_nvlist' mangled-name='nvlist_lookup_nvlist' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_lookup_nvlist'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='857bb57e' name='val'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='nvlist_lookup_boolean_array' mangled-name='nvlist_lookup_boolean_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_lookup_boolean_array'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='03829398' name='a'/>
	<parameter type-id='4dd26a40' name='n'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='nvlist_lookup_byte_array' mangled-name='nvlist_lookup_byte_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_lookup_byte_array'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='3b0247c7' name='a'/>
	<parameter type-id='4dd26a40' name='n'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='nvlist_lookup_int8_array' mangled-name='nvlist_lookup_int8_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_lookup_int8_array'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='ee181ab9' name='a'/>
	<parameter type-id='4dd26a40' name='n'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='nvlist_lookup_uint8_array' mangled-name='nvlist_lookup_uint8_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_lookup_uint8_array'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='d8774064' name='a'/>
	<parameter type-id='4dd26a40' name='n'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='nvlist_lookup_int16_array' mangled-name='nvlist_lookup_int16_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_lookup_int16_array'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='7e73928e' name='a'/>
	<parameter type-id='4dd26a40' name='n'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='nvlist_lookup_uint16_array' mangled-name='nvlist_lookup_uint16_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_lookup_uint16_array'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='bd8768d9' name='a'/>
	<parameter type-id='4dd26a40' name='n'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='nvlist_lookup_int32_array' mangled-name='nvlist_lookup_int32_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_lookup_int32_array'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='9aa04798' name='a'/>
	<parameter type-id='4dd26a40' name='n'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='nvlist_lookup_uint32_array' mangled-name='nvlist_lookup_uint32_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_lookup_uint32_array'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='9507d3c7' name='a'/>
	<parameter type-id='4dd26a40' name='n'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='nvlist_lookup_int64_array' mangled-name='nvlist_lookup_int64_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_lookup_int64_array'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='e37ce48f' name='a'/>
	<parameter type-id='4dd26a40' name='n'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='nvlist_lookup_uint64_array' mangled-name='nvlist_lookup_uint64_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_lookup_uint64_array'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='892b4acc' name='a'/>
	<parameter type-id='4dd26a40' name='n'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='nvlist_lookup_string_array' mangled-name='nvlist_lookup_string_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_lookup_string_array'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='c0563f85' name='a'/>
	<parameter type-id='4dd26a40' name='n'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='nvlist_lookup_nvlist_array' mangled-name='nvlist_lookup_nvlist_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_lookup_nvlist_array'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='75be733c' name='a'/>
	<parameter type-id='4dd26a40' name='n'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='nvlist_lookup_hrtime' mangled-name='nvlist_lookup_hrtime' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_lookup_hrtime'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='e379e62d' name='val'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='nvlist_lookup_pairs' mangled-name='nvlist_lookup_pairs' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_lookup_pairs'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='95e97e5e' name='flag'/>
	<parameter is-variadic='yes'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='nvlist_exists' mangled-name='nvlist_exists' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_exists'>
	+ <function-decl name='nvlist_lookup_nvpair' mangled-name='nvlist_lookup_nvpair' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_lookup_nvpair'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	- <return type-id='c19b74c3'/>
	+ <parameter type-id='0b283d2e' name='ret'/>
	+ <return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='nvlist_lookup_nvpair_embedded_index' mangled-name='nvlist_lookup_nvpair_embedded_index' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_lookup_nvpair_embedded_index'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='0b283d2e' name='ret'/>
	<parameter type-id='7292109c' name='ip'/>
	<parameter type-id='9b23c9ad' name='ep'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='nvlist_lookup_nvpair' mangled-name='nvlist_lookup_nvpair' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_lookup_nvpair'>
	+ <function-decl name='nvlist_exists' mangled-name='nvlist_exists' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_exists'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='80f4b756' name='name'/>
	- <parameter type-id='0b283d2e' name='ret'/>
	- <return type-id='95e97e5e'/>
	+ <return type-id='c19b74c3'/>
	</function-decl>
	<function-decl name='nvlist_add_nvpair' mangled-name='nvlist_add_nvpair' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_add_nvpair'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='3fa542f0' name='nvp'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='nvlist_merge' mangled-name='nvlist_merge' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_merge'>
	<parameter type-id='5ce45b60' name='dst'/>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='95e97e5e' name='flag'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='nvlist_size' mangled-name='nvlist_size' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_size'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='78c01427' name='size'/>
	<parameter type-id='95e97e5e' name='encoding'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='nvlist_xpack' mangled-name='nvlist_xpack' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_xpack'>
	+ <function-decl name='nvlist_pack' mangled-name='nvlist_pack' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_pack'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='9b23c9ad' name='bufp'/>
	<parameter type-id='78c01427' name='buflen'/>
	<parameter type-id='95e97e5e' name='encoding'/>
	- <parameter type-id='11871392' name='nva'/>
	+ <parameter type-id='95e97e5e' name='kmflag'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='nvlist_pack' mangled-name='nvlist_pack' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_pack'>
	+ <function-decl name='nvlist_xpack' mangled-name='nvlist_xpack' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_xpack'>
	<parameter type-id='5ce45b60' name='nvl'/>
	<parameter type-id='9b23c9ad' name='bufp'/>
	<parameter type-id='78c01427' name='buflen'/>
	<parameter type-id='95e97e5e' name='encoding'/>
	- <parameter type-id='95e97e5e' name='kmflag'/>
	+ <parameter type-id='11871392' name='nva'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='nvlist_xunpack' mangled-name='nvlist_xunpack' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_xunpack'>
	+ <function-decl name='nvlist_unpack' mangled-name='nvlist_unpack' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_unpack'>
	<parameter type-id='26a90f95' name='buf'/>
	<parameter type-id='b59d7dce' name='buflen'/>
	<parameter type-id='857bb57e' name='nvlp'/>
	- <parameter type-id='11871392' name='nva'/>
	+ <parameter type-id='95e97e5e' name='kmflag'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='nvlist_unpack' mangled-name='nvlist_unpack' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_unpack'>
	+ <function-decl name='nvlist_xunpack' mangled-name='nvlist_xunpack' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_xunpack'>
	<parameter type-id='26a90f95' name='buf'/>
	<parameter type-id='b59d7dce' name='buflen'/>
	<parameter type-id='857bb57e' name='nvlp'/>
	- <parameter type-id='95e97e5e' name='kmflag'/>
	+ <parameter type-id='11871392' name='nva'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <var-decl name='nvpair_max_recursion' type-id='95e97e5e' mangled-name='nvpair_max_recursion' visibility='default' elf-symbol-id='nvpair_max_recursion'/>
	- <var-decl name='nvlist_hashtable_init_size' type-id='9c313c2d' mangled-name='nvlist_hashtable_init_size' visibility='default' elf-symbol-id='nvlist_hashtable_init_size'/>
	+ <function-decl name='strtol' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='9d26089a'/>
	+ <parameter type-id='8c85230f'/>
	+ <parameter type-id='95e97e5e'/>
	+ <return type-id='bd54fe1a'/>
	+ </function-decl>
	+ <function-decl name='strncmp' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='b59d7dce'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='strchr' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='95e97e5e'/>
	+ <return type-id='26a90f95'/>
	+ </function-decl>
	<function-decl name='strlen' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='80f4b756'/>
	<return type-id='b59d7dce'/>
	</function-decl>
	<function-decl name='xdr_int' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='17fd1621'/>
	<parameter type-id='7292109c'/>
	<return type-id='310a70df'/>
	</function-decl>
	- <function-decl name='xdr_char' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='xdr_u_int' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='17fd1621'/>
	- <parameter type-id='26a90f95'/>
	+ <parameter type-id='b4c2e924'/>
	<return type-id='310a70df'/>
	</function-decl>
	<function-decl name='xdr_short' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='17fd1621'/>
	<parameter type-id='764e437e'/>
	<return type-id='310a70df'/>
	</function-decl>
	<function-decl name='xdr_u_short' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='17fd1621'/>
	<parameter type-id='ede2c2f5'/>
	<return type-id='310a70df'/>
	</function-decl>
	- <function-decl name='xdr_u_int' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='xdr_array' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='17fd1621'/>
	+ <parameter type-id='9b23c9ad'/>
	<parameter type-id='b4c2e924'/>
	+ <parameter type-id='48f7c3f5'/>
	+ <parameter type-id='48f7c3f5'/>
	+ <parameter type-id='c28db3e9'/>
	+ <return type-id='310a70df'/>
	+ </function-decl>
	+ <function-decl name='xdr_opaque' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='17fd1621'/>
	+ <parameter type-id='26a90f95'/>
	+ <parameter type-id='48f7c3f5'/>
	+ <return type-id='310a70df'/>
	+ </function-decl>
	+ <function-decl name='xdr_string' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='17fd1621'/>
	+ <parameter type-id='9b23c9ad'/>
	+ <parameter type-id='48f7c3f5'/>
	+ <return type-id='310a70df'/>
	+ </function-decl>
	+ <function-decl name='xdr_char' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='17fd1621'/>
	+ <parameter type-id='26a90f95'/>
	+ <return type-id='310a70df'/>
	+ </function-decl>
	+ <function-decl name='xdr_double' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='17fd1621'/>
	+ <parameter type-id='7408d286'/>
	<return type-id='310a70df'/>
	</function-decl>
	<function-decl name='xdr_longlong_t' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='17fd1621'/>
	<parameter type-id='de23782d'/>
	<return type-id='310a70df'/>
	</function-decl>
	<function-decl name='xdr_u_longlong_t' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='17fd1621'/>
	<parameter type-id='fce59795'/>
	<return type-id='310a70df'/>
	</function-decl>
	- <function-decl name='bcopy' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='eaa32e2f'/>
	- <parameter type-id='eaa32e2f'/>
	- <parameter type-id='b59d7dce'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	<function-decl name='xdrmem_create' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='17fd1621'/>
	- <parameter type-id='1d276ed1'/>
	+ <parameter type-id='26a90f95'/>
	<parameter type-id='48f7c3f5'/>
	<parameter type-id='6badf1b8'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='xdr_string' visibility='default' binding='global' size-in-bits='64'>
	+ <function-type size-in-bits='64' id='441e0c31'>
	+ <parameter type-id='812c6697'/>
	+ <parameter type-id='48f7c3f5'/>
	+ <return type-id='4aafb922'/>
	+ </function-type>
	+ <function-type size-in-bits='64' id='e80b47fe'>
	<parameter type-id='17fd1621'/>
	- <parameter type-id='9b23c9ad'/>
	+ <parameter is-variadic='yes'/>
	+ <return type-id='310a70df'/>
	+ </function-type>
	+ <function-type size-in-bits='64' id='1c7a4858'>
	+ <parameter type-id='812c6697'/>
	+ <parameter type-id='26a90f95'/>
	<parameter type-id='48f7c3f5'/>
	<return type-id='310a70df'/>
	- </function-decl>
	- <function-decl name='xdr_array' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='17fd1621'/>
	- <parameter type-id='c0ad6580'/>
	- <parameter type-id='b4c2e924'/>
	- <parameter type-id='48f7c3f5'/>
	- <parameter type-id='48f7c3f5'/>
	- <parameter type-id='c28db3e9'/>
	- <return type-id='310a70df'/>
	- </function-decl>
	- <function-decl name='xdr_opaque' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='17fd1621'/>
	- <parameter type-id='02f26d81'/>
	- <parameter type-id='48f7c3f5'/>
	- <return type-id='310a70df'/>
	- </function-decl>
	- <function-decl name='xdr_double' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='17fd1621'/>
	- <parameter type-id='7408d286'/>
	- <return type-id='310a70df'/>
	- </function-decl>
	- <function-decl name='strncmp' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='b59d7dce'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='strtol' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='9b23c9ad'/>
	- <parameter type-id='95e97e5e'/>
	- <return type-id='bd54fe1a'/>
	- </function-decl>
	- <pointer-type-def type-id='37e3bd22' size-in-bits='64' id='03829398'/>
	- <pointer-type-def type-id='26a90f95' size-in-bits='64' id='9b23c9ad'/>
	- <pointer-type-def type-id='9b23c9ad' size-in-bits='64' id='c0563f85'/>
	- <pointer-type-def type-id='aca16c06' size-in-bits='64' id='ee1d4944'/>
	- <type-decl name='double' size-in-bits='64' id='a0eb0f08'/>
	- <pointer-type-def type-id='a0eb0f08' size-in-bits='64' id='7408d286'/>
	- <function-type size-in-bits='64' id='187fc00b'>
	- <parameter type-id='17fd1621'/>
	- <parameter type-id='48f7c3f5'/>
	- <return type-id='4aafb922'/>
	</function-type>
	- <function-type size-in-bits='64' id='35084435'>
	- <parameter type-id='17fd1621'/>
	+ <function-type size-in-bits='64' id='f6358b93'>
	+ <parameter type-id='812c6697'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='48f7c3f5'/>
	<return type-id='310a70df'/>
	</function-type>
	- <function-type size-in-bits='64' id='e9c79c04'>
	- <parameter type-id='17fd1621'/>
	- <parameter type-id='1f526493'/>
	- <return type-id='310a70df'/>
	- </function-type>
	- <function-type size-in-bits='64' id='6b57892c'>
	- <parameter type-id='17fd1621'/>
	+ <function-type size-in-bits='64' id='45354e42'>
	+ <parameter type-id='812c6697'/>
	<parameter type-id='218ee02f'/>
	<return type-id='310a70df'/>
	</function-type>
	- <function-type size-in-bits='64' id='68c52617'>
	- <parameter type-id='17fd1621'/>
	- <parameter type-id='4aafb922'/>
	+ <function-type size-in-bits='64' id='0760d6d1'>
	+ <parameter type-id='812c6697'/>
	+ <parameter type-id='95e97e5e'/>
	+ <parameter type-id='eaa32e2f'/>
	<return type-id='310a70df'/>
	</function-type>
	- <function-type size-in-bits='64' id='4b63097d'>
	- <parameter type-id='17fd1621'/>
	+ <function-type size-in-bits='64' id='be0f9e0b'>
	+ <parameter type-id='812c6697'/>
	<parameter type-id='3ccc2590'/>
	<return type-id='310a70df'/>
	</function-type>
	- <function-type size-in-bits='64' id='cb15e1d2'>
	- <parameter type-id='17fd1621'/>
	- <parameter type-id='02f26d81'/>
	- <parameter type-id='48f7c3f5'/>
	- <return type-id='310a70df'/>
	- </function-type>
	- <function-type size-in-bits='64' id='54decd9e'>
	- <parameter type-id='17fd1621'/>
	+ <function-type size-in-bits='64' id='16eb5704'>
	+ <parameter type-id='812c6697'/>
	<parameter type-id='48f7c3f5'/>
	<return type-id='310a70df'/>
	</function-type>
	- <function-type size-in-bits='64' id='3c81bd20'>
	- <parameter type-id='17fd1621'/>
	- <parameter type-id='eaa32e2f'/>
	- <parameter is-variadic='yes'/>
	- <return type-id='310a70df'/>
	- </function-type>
	- <function-type size-in-bits='64' id='74c0842b'>
	- <parameter type-id='466deafc'/>
	+ <function-type size-in-bits='64' id='46870456'>
	+ <parameter type-id='812c6697'/>
	<return type-id='48f7c3f5'/>
	</function-type>
	- <function-type size-in-bits='64' id='9314f532'>
	- <parameter type-id='17fd1621'/>
	- <return type-id='48b5725f'/>
	- </function-type>
	- <pointer-type-def type-id='cebdd548' size-in-bits='64' id='e379e62d'/>
	- <pointer-type-def type-id='f76f73d0' size-in-bits='64' id='7e73928e'/>
	- <pointer-type-def type-id='4aafb922' size-in-bits='64' id='9aa04798'/>
	- <pointer-type-def type-id='cb785ebf' size-in-bits='64' id='e37ce48f'/>
	- <pointer-type-def type-id='256d5229' size-in-bits='64' id='ee181ab9'/>
	- <pointer-type-def type-id='cca08635' size-in-bits='64' id='11871392'/>
	- <pointer-type-def type-id='857bb57e' size-in-bits='64' id='75be733c'/>
	- <typedef-decl name='hrtime_t' type-id='1eb56b1e' id='cebdd548'/>
	- <pointer-type-def type-id='45b65157' size-in-bits='64' id='3b0247c7'/>
	- <pointer-type-def type-id='8a121f49' size-in-bits='64' id='bd8768d9'/>
	- <pointer-type-def type-id='90421557' size-in-bits='64' id='9507d3c7'/>
	- <pointer-type-def type-id='5d6479ae' size-in-bits='64' id='892b4acc'/>
	- <pointer-type-def type-id='ae3e8ca6' size-in-bits='64' id='d8774064'/>
	- <pointer-type-def type-id='48b5725f' size-in-bits='64' id='eaa32e2f'/>
	- <qualified-type-def type-id='03e8ffd6' const='yes' id='aca16c06'/>
	- <type-decl name='long long int' size-in-bits='64' id='1eb56b1e'/>
	- <typedef-decl name='nv_alloc_t' type-id='98213087' id='cca08635'/>
	- <class-decl name='nv_alloc' size-in-bits='128' is-struct='yes' visibility='default' id='98213087'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='nva_ops' type-id='ee1d4944' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='nva_arg' type-id='eaa32e2f' visibility='default'/>
	- </data-member>
	- </class-decl>
	- <typedef-decl name='nv_alloc_ops_t' type-id='8f6cc4f4' id='03e8ffd6'/>
	- <class-decl name='nv_alloc_ops' size-in-bits='320' is-struct='yes' visibility='default' id='8f6cc4f4'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='nv_ao_init' type-id='76da8447' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='nv_ao_fini' type-id='fe356f6f' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='nv_ao_alloc' type-id='9ff7f508' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='192'>
	- <var-decl name='nv_ao_free' type-id='520da3f4' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='256'>
	- <var-decl name='nv_ao_reset' type-id='fe356f6f' visibility='default'/>
	- </data-member>
	- </class-decl>
	- <pointer-type-def type-id='e9ff7293' size-in-bits='64' id='76da8447'/>
	- <pointer-type-def type-id='51a21b4b' size-in-bits='64' id='fe356f6f'/>
	- <pointer-type-def type-id='1169c032' size-in-bits='64' id='520da3f4'/>
	- <pointer-type-def type-id='9fff962e' size-in-bits='64' id='9ff7f508'/>
	- <function-type size-in-bits='64' id='51a21b4b'>
	- <parameter type-id='11871392' name='nva'/>
	+ <function-type size-in-bits='64' id='c87cb1d0'>
	+ <parameter type-id='812c6697'/>
	<return type-id='48b5725f'/>
	</function-type>
	+ <type-decl name='unsigned long int' size-in-bits='64' id='7359adad'/>
	+ <type-decl name='unsigned short int' size-in-bits='16' id='8efea9e5'/>
	</abi-instr>
	- <abi-instr version='1.0' address-size='64' path='../../module/nvpair/nvpair_alloc_fixed.c' language='LANG_C89'>
	+ <abi-instr address-size='64' path='../../module/nvpair/nvpair_alloc_fixed.c' language='LANG_C99'>
	<var-decl name='nv_fixed_ops' type-id='ee1d4944' mangled-name='nv_fixed_ops' visibility='default' elf-symbol-id='nv_fixed_ops'/>
	<var-decl name='nv_fixed_ops_def' type-id='aca16c06' mangled-name='nv_fixed_ops_def' visibility='default' elf-symbol-id='nv_fixed_ops_def'/>
	</abi-instr>
	- <abi-instr version='1.0' address-size='64' path='libnvpair.c' language='LANG_C89'>
	+ <abi-instr address-size='64' path='libnvpair.c' language='LANG_C99'>
	<type-decl name='char' size-in-bits='8' id='a84c031d'/>
	<array-type-def dimensions='1' type-id='a84c031d' size-in-bits='8' id='89feb1ec'>
	- <subrange length='1' type-id='4c87fef4' id='52f813b4'/>
	+ <subrange length='1' type-id='7359adad' id='52f813b4'/>
	</array-type-def>
	<array-type-def dimensions='1' type-id='a84c031d' size-in-bits='160' id='664ac0b7'>
	- <subrange length='20' type-id='4c87fef4' id='fdca39cf'/>
	+ <subrange length='20' type-id='7359adad' id='fdca39cf'/>
	</array-type-def>
	+ <class-decl name='_IO_codecvt' is-struct='yes' visibility='default' is-declaration-only='yes' id='a4036571'/>
	+ <class-decl name='_IO_marker' is-struct='yes' visibility='default' is-declaration-only='yes' id='010ae0b9'/>
	+ <class-decl name='_IO_wide_data' is-struct='yes' visibility='default' is-declaration-only='yes' id='79bd3751'/>
	+ <class-decl name='re_dfa_t' is-struct='yes' visibility='default' is-declaration-only='yes' id='b48d2441'/>
	<type-decl name='double' size-in-bits='64' id='a0eb0f08'/>
	<type-decl name='int' size-in-bits='32' id='95e97e5e'/>
	<type-decl name='long int' size-in-bits='64' id='bd54fe1a'/>
	<type-decl name='long long int' size-in-bits='64' id='1eb56b1e'/>
	<type-decl name='short int' size-in-bits='16' id='a2185560'/>
	<type-decl name='signed char' size-in-bits='8' id='28577a57'/>
	- <type-decl name='sizetype' size-in-bits='64' id='4c87fef4'/>
	<type-decl name='unnamed-enum-underlying-type-32' is-anonymous='yes' size-in-bits='32' alignment-in-bits='32' id='9cac1fee'/>
	<type-decl name='unsigned char' size-in-bits='8' id='002ac4a6'/>
	<type-decl name='unsigned int' size-in-bits='32' id='f0981eeb'/>
	<type-decl name='unsigned long int' size-in-bits='64' id='7359adad'/>
	<type-decl name='unsigned short int' size-in-bits='16' id='8efea9e5'/>
	<type-decl name='variadic parameter type' id='2c1145c5'/>
	<type-decl name='void' id='48b5725f'/>
	<typedef-decl name='nvlist_prtctl_t' type-id='196db161' id='b0c1ff8d'/>
	- <class-decl name='nvlist_prtctl' size-in-bits='576' is-struct='yes' visibility='default' id='d2e8bad9'>
	+ <enum-decl name='nvlist_indent_mode' id='628aafab'>
	+ <underlying-type type-id='9cac1fee'/>
	+ <enumerator name='NVLIST_INDENT_ABS' value='0'/>
	+ <enumerator name='NVLIST_INDENT_TABBED' value='1'/>
	+ </enum-decl>
	+ <enum-decl name='nvlist_prtctl_fmt' id='c8dcc53a'>
	+ <underlying-type type-id='9cac1fee'/>
	+ <enumerator name='NVLIST_FMT_MEMBER_NAME' value='0'/>
	+ <enumerator name='NVLIST_FMT_MEMBER_POSTAMBLE' value='1'/>
	+ <enumerator name='NVLIST_FMT_BTWN_ARRAY' value='2'/>
	+ </enum-decl>
	+ <enum-decl name='data_type_t' naming-typedef-id='8d0687d2' id='aeeae136'>
	+ <underlying-type type-id='9cac1fee'/>
	+ <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='aeeae136' id='8d0687d2'/>
	+ <class-decl name='nvpair' size-in-bits='128' is-struct='yes' visibility='default' id='1c34e459'>
	<data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='nvprt_fp' type-id='822cd80b' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='nvprt_indent_mode' type-id='628aafab' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='96'>
	- <var-decl name='nvprt_indent' type-id='95e97e5e' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='nvprt_indentinc' type-id='95e97e5e' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='192'>
	- <var-decl name='nvprt_nmfmt' type-id='80f4b756' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='256'>
	- <var-decl name='nvprt_eomfmt' type-id='80f4b756' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='320'>
	- <var-decl name='nvprt_btwnarrfmt' type-id='80f4b756' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='384'>
	- <var-decl name='nvprt_btwnarrfmt_nl' type-id='95e97e5e' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='448'>
	- <var-decl name='nvprt_dfltops' type-id='7be54adb' visibility='default'/>
	+ <var-decl name='nvp_size' type-id='3ff5601b' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='512'>
	- <var-decl name='nvprt_custops' type-id='7be54adb' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='32'>
	+ <var-decl name='nvp_name_sz' type-id='23bd8cb5' visibility='default'/>
	</data-member>
	- </class-decl>
	- <typedef-decl name='FILE' type-id='ec1ed955' id='aa12d1ba'/>
	- <class-decl name='_IO_FILE' size-in-bits='1728' is-struct='yes' visibility='default' id='ec1ed955'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='_flags' type-id='95e97e5e' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='48'>
	+ <var-decl name='nvp_reserve' type-id='23bd8cb5' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='_IO_read_ptr' type-id='26a90f95' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='_IO_read_end' type-id='26a90f95' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='192'>
	- <var-decl name='_IO_read_base' type-id='26a90f95' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='256'>
	- <var-decl name='_IO_write_base' type-id='26a90f95' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='320'>
	- <var-decl name='_IO_write_ptr' type-id='26a90f95' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='384'>
	- <var-decl name='_IO_write_end' type-id='26a90f95' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='448'>
	- <var-decl name='_IO_buf_base' type-id='26a90f95' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='512'>
	- <var-decl name='_IO_buf_end' type-id='26a90f95' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='576'>
	- <var-decl name='_IO_save_base' type-id='26a90f95' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='640'>
	- <var-decl name='_IO_backup_base' type-id='26a90f95' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='704'>
	- <var-decl name='_IO_save_end' type-id='26a90f95' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='768'>
	- <var-decl name='_markers' type-id='e4c6fa61' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='832'>
	- <var-decl name='_chain' type-id='dca988a5' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='896'>
	- <var-decl name='_fileno' type-id='95e97e5e' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='928'>
	- <var-decl name='_flags2' type-id='95e97e5e' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='960'>
	- <var-decl name='_old_offset' type-id='79989e9c' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='1024'>
	- <var-decl name='_cur_column' type-id='8efea9e5' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='1040'>
	- <var-decl name='_vtable_offset' type-id='28577a57' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='1048'>
	- <var-decl name='_shortbuf' type-id='89feb1ec' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='1088'>
	- <var-decl name='_lock' type-id='cecf4ea7' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='1152'>
	- <var-decl name='_offset' type-id='724e4de6' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='1216'>
	- <var-decl name='__pad1' type-id='eaa32e2f' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='1280'>
	- <var-decl name='__pad2' type-id='eaa32e2f' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='1344'>
	- <var-decl name='__pad3' type-id='eaa32e2f' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='1408'>
	- <var-decl name='__pad4' type-id='eaa32e2f' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='1472'>
	- <var-decl name='__pad5' type-id='b59d7dce' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='1536'>
	- <var-decl name='_mode' type-id='95e97e5e' visibility='default'/>
	+ <var-decl name='nvp_value_elem' type-id='3ff5601b' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='1568'>
	- <var-decl name='_unused2' type-id='664ac0b7' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='96'>
	+ <var-decl name='nvp_type' type-id='8d0687d2' visibility='default'/>
	</data-member>
	</class-decl>
	- <class-decl name='_IO_marker' size-in-bits='192' is-struct='yes' visibility='default' id='010ae0b9'>
	+ <typedef-decl name='nvpair_t' type-id='1c34e459' id='57928edf'/>
	+ <class-decl name='nvlist' size-in-bits='192' is-struct='yes' visibility='default' id='ac266fd9'>
	<data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='_next' type-id='e4c6fa61' visibility='default'/>
	+ <var-decl name='nvl_version' type-id='3ff5601b' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='32'>
	+ <var-decl name='nvl_nvflag' type-id='8f92235e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='_sbuf' type-id='dca988a5' visibility='default'/>
	+ <var-decl name='nvl_priv' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='_pos' type-id='95e97e5e' visibility='default'/>
	+ <var-decl name='nvl_flag' type-id='8f92235e' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='160'>
	+ <var-decl name='nvl_pad' type-id='3ff5601b' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='__off_t' type-id='bd54fe1a' id='79989e9c'/>
	- <typedef-decl name='_IO_lock_t' type-id='48b5725f' id='bb4788fa'/>
	- <typedef-decl name='__off64_t' type-id='bd54fe1a' id='724e4de6'/>
	- <typedef-decl name='size_t' type-id='7359adad' id='b59d7dce'/>
	- <enum-decl name='nvlist_indent_mode' id='628aafab'>
	+ <typedef-decl name='nvlist_t' type-id='ac266fd9' id='8e8d4be3'/>
	+ <enum-decl name='boolean_t' naming-typedef-id='c19b74c3' id='f58c8277'>
	<underlying-type type-id='9cac1fee'/>
	- <enumerator name='NVLIST_INDENT_ABS' value='0'/>
	- <enumerator name='NVLIST_INDENT_TABBED' value='1'/>
	+ <enumerator name='B_FALSE' value='0'/>
	+ <enumerator name='B_TRUE' value='1'/>
	</enum-decl>
	+ <typedef-decl name='boolean_t' type-id='f58c8277' id='c19b74c3'/>
	+ <typedef-decl name='uchar_t' type-id='002ac4a6' id='d8bf0010'/>
	+ <typedef-decl name='uint_t' type-id='f0981eeb' id='3502e3ff'/>
	+ <typedef-decl name='hrtime_t' type-id='1eb56b1e' id='cebdd548'/>
	<class-decl name='nvlist_printops' size-in-bits='3456' is-struct='yes' visibility='default' id='ebc6735b'>
	<data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='print_boolean' type-id='47d8e2d1' visibility='default'/>
	+ <var-decl name='print_boolean' type-id='e7f43f72' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='print_boolean_value' type-id='8a6f2dcc' visibility='default'/>
	+ <var-decl name='print_boolean_value' type-id='e7f43f73' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='256'>
	- <var-decl name='print_byte' type-id='bdf563df' visibility='default'/>
	+ <var-decl name='print_byte' type-id='e7f43f74' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='384'>
	- <var-decl name='print_int8' type-id='5636b8e3' visibility='default'/>
	+ <var-decl name='print_int8' type-id='e7f43f75' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='512'>
	- <var-decl name='print_uint8' type-id='0119a618' visibility='default'/>
	+ <var-decl name='print_uint8' type-id='e7f43f76' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='640'>
	- <var-decl name='print_int16' type-id='4657e0ba' visibility='default'/>
	+ <var-decl name='print_int16' type-id='e7f43f77' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='768'>
	- <var-decl name='print_uint16' type-id='ecfe67d7' visibility='default'/>
	+ <var-decl name='print_uint16' type-id='e7f43f78' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='896'>
	- <var-decl name='print_int32' type-id='8947fe4c' visibility='default'/>
	+ <var-decl name='print_int32' type-id='e7f43f79' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='1024'>
	- <var-decl name='print_uint32' type-id='365a6549' visibility='default'/>
	+ <var-decl name='print_uint32' type-id='e7f43f7a' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='1152'>
	- <var-decl name='print_int64' type-id='d6ce379b' visibility='default'/>
	+ <var-decl name='print_int64' type-id='e7f43f7b' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='1280'>
	- <var-decl name='print_uint64' type-id='bb34572a' visibility='default'/>
	+ <var-decl name='print_uint64' type-id='e7f43f7c' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='1408'>
	- <var-decl name='print_double' type-id='ef32d857' visibility='default'/>
	+ <var-decl name='print_double' type-id='e7f43f7d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='1536'>
	- <var-decl name='print_string' type-id='f6ce752a' visibility='default'/>
	+ <var-decl name='print_string' type-id='e7f43f7e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='1664'>
	- <var-decl name='print_hrtime' type-id='c61b59cf' visibility='default'/>
	+ <var-decl name='print_hrtime' type-id='e7f43f7f' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='1792'>
	- <var-decl name='print_nvlist' type-id='1178977f' visibility='default'/>
	+ <var-decl name='print_nvlist' type-id='e7f43f80' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='1920'>
	- <var-decl name='print_boolean_array' type-id='15d12763' visibility='default'/>
	+ <var-decl name='print_boolean_array' type-id='e7f43f81' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='2048'>
	- <var-decl name='print_byte_array' type-id='4207d3e6' visibility='default'/>
	+ <var-decl name='print_byte_array' type-id='e7f43f82' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='2176'>
	- <var-decl name='print_int8_array' type-id='e4cdea78' visibility='default'/>
	+ <var-decl name='print_int8_array' type-id='e7f43f83' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='2304'>
	- <var-decl name='print_uint8_array' type-id='252509cf' visibility='default'/>
	+ <var-decl name='print_uint8_array' type-id='e7f43f84' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='2432'>
	- <var-decl name='print_int16_array' type-id='3cf98639' visibility='default'/>
	+ <var-decl name='print_int16_array' type-id='e7f43f85' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='2560'>
	- <var-decl name='print_uint16_array' type-id='060bdb18' visibility='default'/>
	+ <var-decl name='print_uint16_array' type-id='e7f43f86' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='2688'>
	- <var-decl name='print_int32_array' type-id='bbaa8a1b' visibility='default'/>
	+ <var-decl name='print_int32_array' type-id='e7f43f87' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='2816'>
	- <var-decl name='print_uint32_array' type-id='745b46ee' visibility='default'/>
	+ <var-decl name='print_uint32_array' type-id='e7f43f88' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='2944'>
	- <var-decl name='print_int64_array' type-id='223df2d6' visibility='default'/>
	+ <var-decl name='print_int64_array' type-id='e7f43f89' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='3072'>
	- <var-decl name='print_uint64_array' type-id='f564486f' visibility='default'/>
	+ <var-decl name='print_uint64_array' type-id='e7f43f8a' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='3200'>
	- <var-decl name='print_string_array' type-id='f15f91ac' visibility='default'/>
	+ <var-decl name='print_string_array' type-id='e7f43f8b' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='3328'>
	- <var-decl name='print_nvlist_array' type-id='f885c1bf' visibility='default'/>
	+ <var-decl name='print_nvlist_array' type-id='e7f43f8c' visibility='default'/>
	</data-member>
	</class-decl>
	- <class-decl name='__anonymous_struct__' size-in-bits='128' is-struct='yes' is-anonymous='yes' visibility='default' id='47d8e2d1'>
	+ <class-decl name='__anonymous_struct__' size-in-bits='128' is-struct='yes' is-anonymous='yes' visibility='default' id='e7f43f72'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='op' type-id='6d994334' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='arg' type-id='eaa32e2f' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='nvlist_t' type-id='ac266fd9' id='8e8d4be3'/>
	- <class-decl name='nvlist' size-in-bits='192' is-struct='yes' visibility='default' id='ac266fd9'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='nvl_version' type-id='3ff5601b' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='32'>
	- <var-decl name='nvl_nvflag' type-id='8f92235e' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='nvl_priv' type-id='9c313c2d' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='nvl_flag' type-id='8f92235e' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='160'>
	- <var-decl name='nvl_pad' type-id='3ff5601b' visibility='default'/>
	- </data-member>
	- </class-decl>
	- <typedef-decl name='int32_t' type-id='95e97e5e' id='3ff5601b'/>
	- <typedef-decl name='uint32_t' type-id='f0981eeb' id='8f92235e'/>
	- <typedef-decl name='uint64_t' type-id='7359adad' id='9c313c2d'/>
	- <class-decl name='__anonymous_struct__1' size-in-bits='128' is-struct='yes' is-anonymous='yes' visibility='default' id='8a6f2dcc'>
	+ <class-decl name='__anonymous_struct__1' size-in-bits='128' is-struct='yes' is-anonymous='yes' visibility='default' id='e7f43f73'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='op' type-id='6a2f50c1' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='arg' type-id='eaa32e2f' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='boolean_t' type-id='08f5ca17' id='c19b74c3'/>
	- <enum-decl name='__anonymous_enum__' is-anonymous='yes' id='08f5ca17'>
	- <underlying-type type-id='9cac1fee'/>
	- <enumerator name='B_FALSE' value='0'/>
	- <enumerator name='B_TRUE' value='1'/>
	- </enum-decl>
	- <class-decl name='__anonymous_struct__2' size-in-bits='128' is-struct='yes' is-anonymous='yes' visibility='default' id='bdf563df'>
	+ <class-decl name='__anonymous_struct__2' size-in-bits='128' is-struct='yes' is-anonymous='yes' visibility='default' id='e7f43f74'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='op' type-id='8a1fb33a' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='arg' type-id='eaa32e2f' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='uchar_t' type-id='002ac4a6' id='d8bf0010'/>
	- <class-decl name='__anonymous_struct__3' size-in-bits='128' is-struct='yes' is-anonymous='yes' visibility='default' id='5636b8e3'>
	+ <class-decl name='__anonymous_struct__3' size-in-bits='128' is-struct='yes' is-anonymous='yes' visibility='default' id='e7f43f75'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='op' type-id='506696a8' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='arg' type-id='eaa32e2f' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='int8_t' type-id='28577a57' id='ee31ee44'/>
	- <class-decl name='__anonymous_struct__4' size-in-bits='128' is-struct='yes' is-anonymous='yes' visibility='default' id='0119a618'>
	+ <class-decl name='__anonymous_struct__4' size-in-bits='128' is-struct='yes' is-anonymous='yes' visibility='default' id='e7f43f76'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='op' type-id='39b623f9' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='arg' type-id='eaa32e2f' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='uint8_t' type-id='002ac4a6' id='b96825af'/>
	- <class-decl name='__anonymous_struct__5' size-in-bits='128' is-struct='yes' is-anonymous='yes' visibility='default' id='4657e0ba'>
	+ <class-decl name='__anonymous_struct__5' size-in-bits='128' is-struct='yes' is-anonymous='yes' visibility='default' id='e7f43f77'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='op' type-id='ea6be4eb' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='arg' type-id='eaa32e2f' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='int16_t' type-id='a2185560' id='23bd8cb5'/>
	- <class-decl name='__anonymous_struct__6' size-in-bits='128' is-struct='yes' is-anonymous='yes' visibility='default' id='ecfe67d7'>
	+ <class-decl name='__anonymous_struct__6' size-in-bits='128' is-struct='yes' is-anonymous='yes' visibility='default' id='e7f43f78'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='op' type-id='f10f1e84' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='arg' type-id='eaa32e2f' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='uint16_t' type-id='8efea9e5' id='149c6638'/>
	- <class-decl name='__anonymous_struct__7' size-in-bits='128' is-struct='yes' is-anonymous='yes' visibility='default' id='8947fe4c'>
	+ <class-decl name='__anonymous_struct__7' size-in-bits='128' is-struct='yes' is-anonymous='yes' visibility='default' id='e7f43f79'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='op' type-id='1708018d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='arg' type-id='eaa32e2f' visibility='default'/>
	</data-member>
	</class-decl>
	- <class-decl name='__anonymous_struct__8' size-in-bits='128' is-struct='yes' is-anonymous='yes' visibility='default' id='365a6549'>
	+ <class-decl name='__anonymous_struct__8' size-in-bits='128' is-struct='yes' is-anonymous='yes' visibility='default' id='e7f43f7a'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='op' type-id='90174072' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='arg' type-id='eaa32e2f' visibility='default'/>
	</data-member>
	</class-decl>
	- <class-decl name='__anonymous_struct__9' size-in-bits='128' is-struct='yes' is-anonymous='yes' visibility='default' id='d6ce379b'>
	+ <class-decl name='__anonymous_struct__9' size-in-bits='128' is-struct='yes' is-anonymous='yes' visibility='default' id='e7f43f7b'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='op' type-id='d2af7f32' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='arg' type-id='eaa32e2f' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='int64_t' type-id='bd54fe1a' id='9da381c4'/>
	- <class-decl name='__anonymous_struct__10' size-in-bits='128' is-struct='yes' is-anonymous='yes' visibility='default' id='bb34572a'>
	+ <class-decl name='__anonymous_struct__10' size-in-bits='128' is-struct='yes' is-anonymous='yes' visibility='default' id='e7f43f7c'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='op' type-id='0b22f759' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='arg' type-id='eaa32e2f' visibility='default'/>
	</data-member>
	</class-decl>
	- <class-decl name='__anonymous_struct__11' size-in-bits='128' is-struct='yes' is-anonymous='yes' visibility='default' id='ef32d857'>
	+ <class-decl name='__anonymous_struct__11' size-in-bits='128' is-struct='yes' is-anonymous='yes' visibility='default' id='e7f43f7d'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='op' type-id='3be4d568' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='arg' type-id='eaa32e2f' visibility='default'/>
	</data-member>
	</class-decl>
	- <class-decl name='__anonymous_struct__12' size-in-bits='128' is-struct='yes' is-anonymous='yes' visibility='default' id='f6ce752a'>
	+ <class-decl name='__anonymous_struct__12' size-in-bits='128' is-struct='yes' is-anonymous='yes' visibility='default' id='e7f43f7e'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='op' type-id='c0d0f877' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='arg' type-id='eaa32e2f' visibility='default'/>
	</data-member>
	</class-decl>
	- <class-decl name='__anonymous_struct__13' size-in-bits='128' is-struct='yes' is-anonymous='yes' visibility='default' id='c61b59cf'>
	+ <class-decl name='__anonymous_struct__13' size-in-bits='128' is-struct='yes' is-anonymous='yes' visibility='default' id='e7f43f7f'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='op' type-id='e1c54c3c' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='arg' type-id='eaa32e2f' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='hrtime_t' type-id='1eb56b1e' id='cebdd548'/>
	- <class-decl name='__anonymous_struct__14' size-in-bits='128' is-struct='yes' is-anonymous='yes' visibility='default' id='1178977f'>
	+ <class-decl name='__anonymous_struct__14' size-in-bits='128' is-struct='yes' is-anonymous='yes' visibility='default' id='e7f43f80'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='op' type-id='19ea27ae' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='arg' type-id='eaa32e2f' visibility='default'/>
	</data-member>
	</class-decl>
	- <class-decl name='__anonymous_struct__15' size-in-bits='128' is-struct='yes' is-anonymous='yes' visibility='default' id='15d12763'>
	+ <class-decl name='__anonymous_struct__15' size-in-bits='128' is-struct='yes' is-anonymous='yes' visibility='default' id='e7f43f81'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='op' type-id='7ef0e988' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='arg' type-id='eaa32e2f' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='uint_t' type-id='f0981eeb' id='3502e3ff'/>
	- <class-decl name='__anonymous_struct__16' size-in-bits='128' is-struct='yes' is-anonymous='yes' visibility='default' id='4207d3e6'>
	+ <class-decl name='__anonymous_struct__16' size-in-bits='128' is-struct='yes' is-anonymous='yes' visibility='default' id='e7f43f82'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='op' type-id='7391ed39' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='arg' type-id='eaa32e2f' visibility='default'/>
	</data-member>
	</class-decl>
	- <class-decl name='__anonymous_struct__17' size-in-bits='128' is-struct='yes' is-anonymous='yes' visibility='default' id='e4cdea78'>
	+ <class-decl name='__anonymous_struct__17' size-in-bits='128' is-struct='yes' is-anonymous='yes' visibility='default' id='e7f43f83'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='op' type-id='42257af5' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='arg' type-id='eaa32e2f' visibility='default'/>
	</data-member>
	</class-decl>
	- <class-decl name='__anonymous_struct__18' size-in-bits='128' is-struct='yes' is-anonymous='yes' visibility='default' id='252509cf'>
	+ <class-decl name='__anonymous_struct__18' size-in-bits='128' is-struct='yes' is-anonymous='yes' visibility='default' id='e7f43f84'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='op' type-id='330cc0d0' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='arg' type-id='eaa32e2f' visibility='default'/>
	</data-member>
	</class-decl>
	- <class-decl name='__anonymous_struct__19' size-in-bits='128' is-struct='yes' is-anonymous='yes' visibility='default' id='3cf98639'>
	+ <class-decl name='__anonymous_struct__19' size-in-bits='128' is-struct='yes' is-anonymous='yes' visibility='default' id='e7f43f85'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='op' type-id='506ab59a' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='arg' type-id='eaa32e2f' visibility='default'/>
	</data-member>
	</class-decl>
	- <class-decl name='__anonymous_struct__20' size-in-bits='128' is-struct='yes' is-anonymous='yes' visibility='default' id='060bdb18'>
	+ <class-decl name='__anonymous_struct__20' size-in-bits='128' is-struct='yes' is-anonymous='yes' visibility='default' id='e7f43f86'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='op' type-id='ed6a3a3d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='arg' type-id='eaa32e2f' visibility='default'/>
	</data-member>
	</class-decl>
	- <class-decl name='__anonymous_struct__21' size-in-bits='128' is-struct='yes' is-anonymous='yes' visibility='default' id='bbaa8a1b'>
	+ <class-decl name='__anonymous_struct__21' size-in-bits='128' is-struct='yes' is-anonymous='yes' visibility='default' id='e7f43f87'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='op' type-id='750cc41c' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='arg' type-id='eaa32e2f' visibility='default'/>
	</data-member>
	</class-decl>
	- <class-decl name='__anonymous_struct__22' size-in-bits='128' is-struct='yes' is-anonymous='yes' visibility='default' id='745b46ee'>
	+ <class-decl name='__anonymous_struct__22' size-in-bits='128' is-struct='yes' is-anonymous='yes' visibility='default' id='e7f43f88'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='op' type-id='292cdbcf' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='arg' type-id='eaa32e2f' visibility='default'/>
	</data-member>
	</class-decl>
	- <class-decl name='__anonymous_struct__23' size-in-bits='128' is-struct='yes' is-anonymous='yes' visibility='default' id='223df2d6'>
	+ <class-decl name='__anonymous_struct__23' size-in-bits='128' is-struct='yes' is-anonymous='yes' visibility='default' id='e7f43f89'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='op' type-id='aaea91b5' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='arg' type-id='eaa32e2f' visibility='default'/>
	</data-member>
	</class-decl>
	- <class-decl name='__anonymous_struct__24' size-in-bits='128' is-struct='yes' is-anonymous='yes' visibility='default' id='f564486f'>
	+ <class-decl name='__anonymous_struct__24' size-in-bits='128' is-struct='yes' is-anonymous='yes' visibility='default' id='e7f43f8a'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='op' type-id='7e85a9b6' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='arg' type-id='eaa32e2f' visibility='default'/>
	</data-member>
	</class-decl>
	- <class-decl name='__anonymous_struct__25' size-in-bits='128' is-struct='yes' is-anonymous='yes' visibility='default' id='f15f91ac'>
	+ <class-decl name='__anonymous_struct__25' size-in-bits='128' is-struct='yes' is-anonymous='yes' visibility='default' id='e7f43f8b'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='op' type-id='de20bf07' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='arg' type-id='eaa32e2f' visibility='default'/>
	</data-member>
	</class-decl>
	- <class-decl name='__anonymous_struct__26' size-in-bits='128' is-struct='yes' is-anonymous='yes' visibility='default' id='f885c1bf'>
	+ <class-decl name='__anonymous_struct__26' size-in-bits='128' is-struct='yes' is-anonymous='yes' visibility='default' id='e7f43f8c'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='op' type-id='2835af80' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='arg' type-id='eaa32e2f' visibility='default'/>
	</data-member>
	</class-decl>
	- <enum-decl name='nvlist_prtctl_fmt' id='c8dcc53a'>
	- <underlying-type type-id='9cac1fee'/>
	- <enumerator name='NVLIST_FMT_MEMBER_NAME' value='0'/>
	- <enumerator name='NVLIST_FMT_MEMBER_POSTAMBLE' value='1'/>
	- <enumerator name='NVLIST_FMT_BTWN_ARRAY' value='2'/>
	- </enum-decl>
	- <typedef-decl name='nvpair_t' type-id='1c34e459' id='57928edf'/>
	- <class-decl name='nvpair' size-in-bits='128' is-struct='yes' visibility='default' id='1c34e459'>
	+ <class-decl name='nvlist_prtctl' size-in-bits='576' is-struct='yes' visibility='default' id='d2e8bad9'>
	<data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='nvp_size' type-id='3ff5601b' visibility='default'/>
	+ <var-decl name='nvprt_fp' type-id='822cd80b' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='32'>
	- <var-decl name='nvp_name_sz' type-id='23bd8cb5' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='64'>
	+ <var-decl name='nvprt_indent_mode' type-id='628aafab' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='48'>
	- <var-decl name='nvp_reserve' type-id='23bd8cb5' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='96'>
	+ <var-decl name='nvprt_indent' type-id='95e97e5e' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='128'>
	+ <var-decl name='nvprt_indentinc' type-id='95e97e5e' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='192'>
	+ <var-decl name='nvprt_nmfmt' type-id='80f4b756' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='256'>
	+ <var-decl name='nvprt_eomfmt' type-id='80f4b756' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='320'>
	+ <var-decl name='nvprt_btwnarrfmt' type-id='80f4b756' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='384'>
	+ <var-decl name='nvprt_btwnarrfmt_nl' type-id='95e97e5e' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='448'>
	+ <var-decl name='nvprt_dfltops' type-id='7be54adb' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='512'>
	+ <var-decl name='nvprt_custops' type-id='7be54adb' visibility='default'/>
	+ </data-member>
	+ </class-decl>
	+ <typedef-decl name='int8_t' type-id='2171a512' id='ee31ee44'/>
	+ <typedef-decl name='int16_t' type-id='03896e23' id='23bd8cb5'/>
	+ <typedef-decl name='int32_t' type-id='33f57a65' id='3ff5601b'/>
	+ <typedef-decl name='int64_t' type-id='0c9942d2' id='9da381c4'/>
	+ <typedef-decl name='uint8_t' type-id='c51d6389' id='b96825af'/>
	+ <typedef-decl name='uint16_t' type-id='253c2d2a' id='149c6638'/>
	+ <typedef-decl name='uint32_t' type-id='62f1140c' id='8f92235e'/>
	+ <typedef-decl name='uint64_t' type-id='8910171f' id='9c313c2d'/>
	+ <typedef-decl name='__int8_t' type-id='28577a57' id='2171a512'/>
	+ <typedef-decl name='__uint8_t' type-id='002ac4a6' id='c51d6389'/>
	+ <typedef-decl name='__int16_t' type-id='a2185560' id='03896e23'/>
	+ <typedef-decl name='__uint16_t' type-id='8efea9e5' id='253c2d2a'/>
	+ <typedef-decl name='__int32_t' type-id='95e97e5e' id='33f57a65'/>
	+ <typedef-decl name='__uint32_t' type-id='f0981eeb' id='62f1140c'/>
	+ <typedef-decl name='__int64_t' type-id='bd54fe1a' id='0c9942d2'/>
	+ <typedef-decl name='__uint64_t' type-id='7359adad' id='8910171f'/>
	+ <typedef-decl name='__off_t' type-id='bd54fe1a' id='79989e9c'/>
	+ <typedef-decl name='__off64_t' type-id='bd54fe1a' id='724e4de6'/>
	+ <typedef-decl name='FILE' type-id='ec1ed955' id='aa12d1ba'/>
	+ <typedef-decl name='_IO_lock_t' type-id='48b5725f' id='bb4788fa'/>
	+ <class-decl name='_IO_FILE' size-in-bits='1728' is-struct='yes' visibility='default' id='ec1ed955'>
	+ <data-member access='public' layout-offset-in-bits='0'>
	+ <var-decl name='_flags' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='nvp_value_elem' type-id='3ff5601b' visibility='default'/>
	+ <var-decl name='_IO_read_ptr' type-id='26a90f95' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='96'>
	- <var-decl name='nvp_type' type-id='8d0687d2' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='128'>
	+ <var-decl name='_IO_read_end' type-id='26a90f95' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='192'>
	+ <var-decl name='_IO_read_base' type-id='26a90f95' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='256'>
	+ <var-decl name='_IO_write_base' type-id='26a90f95' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='320'>
	+ <var-decl name='_IO_write_ptr' type-id='26a90f95' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='384'>
	+ <var-decl name='_IO_write_end' type-id='26a90f95' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='448'>
	+ <var-decl name='_IO_buf_base' type-id='26a90f95' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='512'>
	+ <var-decl name='_IO_buf_end' type-id='26a90f95' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='576'>
	+ <var-decl name='_IO_save_base' type-id='26a90f95' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='640'>
	+ <var-decl name='_IO_backup_base' type-id='26a90f95' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='704'>
	+ <var-decl name='_IO_save_end' type-id='26a90f95' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='768'>
	+ <var-decl name='_markers' type-id='e4c6fa61' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='832'>
	+ <var-decl name='_chain' type-id='dca988a5' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='896'>
	+ <var-decl name='_fileno' type-id='95e97e5e' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='928'>
	+ <var-decl name='_flags2' type-id='95e97e5e' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='960'>
	+ <var-decl name='_old_offset' type-id='79989e9c' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='1024'>
	+ <var-decl name='_cur_column' type-id='8efea9e5' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='1040'>
	+ <var-decl name='_vtable_offset' type-id='28577a57' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='1048'>
	+ <var-decl name='_shortbuf' type-id='89feb1ec' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='1088'>
	+ <var-decl name='_lock' type-id='cecf4ea7' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='1152'>
	+ <var-decl name='_offset' type-id='724e4de6' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='1216'>
	+ <var-decl name='_codecvt' type-id='570f8c59' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='1280'>
	+ <var-decl name='_wide_data' type-id='c65a1f29' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='1344'>
	+ <var-decl name='_freeres_list' type-id='dca988a5' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='1408'>
	+ <var-decl name='_freeres_buf' type-id='eaa32e2f' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='1472'>
	+ <var-decl name='__pad5' type-id='b59d7dce' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='1536'>
	+ <var-decl name='_mode' type-id='95e97e5e' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='1568'>
	+ <var-decl name='_unused2' type-id='664ac0b7' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='data_type_t' type-id='40ed39d2' id='8d0687d2'/>
	- <enum-decl name='__anonymous_enum__1' is-anonymous='yes' id='40ed39d2'>
	- <underlying-type type-id='9cac1fee'/>
	- <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='regex_t' type-id='19fc9a8c' id='aca3bac8'/>
	+ <typedef-decl name='__re_long_size_t' type-id='7359adad' id='ba516949'/>
	+ <typedef-decl name='reg_syntax_t' type-id='7359adad' id='1b72c3b3'/>
	<class-decl name='re_pattern_buffer' size-in-bits='512' is-struct='yes' visibility='default' id='19fc9a8c'>
	<data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='buffer' type-id='cf536864' visibility='default'/>
	+ <var-decl name='buffer' type-id='33976309' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='allocated' type-id='7359adad' visibility='default'/>
	+ <var-decl name='allocated' type-id='ba516949' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='used' type-id='7359adad' visibility='default'/>
	+ <var-decl name='used' type-id='ba516949' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	<var-decl name='syntax' type-id='1b72c3b3' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='256'>
	<var-decl name='fastmap' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='320'>
	<var-decl name='translate' type-id='cf536864' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='384'>
	<var-decl name='re_nsub' type-id='b59d7dce' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='31'>
	+ <data-member access='public' layout-offset-in-bits='448'>
	<var-decl name='can_be_null' type-id='f0981eeb' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='29'>
	+ <data-member access='public' layout-offset-in-bits='449'>
	<var-decl name='regs_allocated' type-id='f0981eeb' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='28'>
	+ <data-member access='public' layout-offset-in-bits='451'>
	<var-decl name='fastmap_accurate' type-id='f0981eeb' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='27'>
	+ <data-member access='public' layout-offset-in-bits='452'>
	<var-decl name='no_sub' type-id='f0981eeb' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='26'>
	+ <data-member access='public' layout-offset-in-bits='453'>
	<var-decl name='not_bol' type-id='f0981eeb' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='25'>
	+ <data-member access='public' layout-offset-in-bits='454'>
	<var-decl name='not_eol' type-id='f0981eeb' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='24'>
	+ <data-member access='public' layout-offset-in-bits='455'>
	<var-decl name='newline_anchor' type-id='f0981eeb' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='reg_syntax_t' type-id='7359adad' id='1b72c3b3'/>
	- <typedef-decl name='regmatch_t' type-id='94e04c73' id='1b941664'/>
	- <class-decl name='__anonymous_struct__27' size-in-bits='64' is-struct='yes' is-anonymous='yes' naming-typedef-id='1b941664' visibility='default' id='94e04c73'>
	+ <typedef-decl name='regex_t' type-id='19fc9a8c' id='aca3bac8'/>
	+ <typedef-decl name='regoff_t' type-id='95e97e5e' id='54a2a2a8'/>
	+ <class-decl name='regmatch_t' size-in-bits='64' is-struct='yes' naming-typedef-id='1b941664' visibility='default' id='4f932615'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='rm_so' type-id='54a2a2a8' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='32'>
	<var-decl name='rm_eo' type-id='54a2a2a8' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='regoff_t' type-id='95e97e5e' id='54a2a2a8'/>
	+ <typedef-decl name='regmatch_t' type-id='4f932615' id='1b941664'/>
	+ <typedef-decl name='size_t' type-id='7359adad' id='b59d7dce'/>
	<pointer-type-def type-id='aa12d1ba' size-in-bits='64' id='822cd80b'/>
	+ <qualified-type-def type-id='822cd80b' restrict='yes' id='e75a27e9'/>
	<pointer-type-def type-id='ec1ed955' size-in-bits='64' id='dca988a5'/>
	+ <pointer-type-def type-id='a4036571' size-in-bits='64' id='570f8c59'/>
	<pointer-type-def type-id='bb4788fa' size-in-bits='64' id='cecf4ea7'/>
	<pointer-type-def type-id='010ae0b9' size-in-bits='64' id='e4c6fa61'/>
	+ <pointer-type-def type-id='79bd3751' size-in-bits='64' id='c65a1f29'/>
	<pointer-type-def type-id='c19b74c3' size-in-bits='64' id='37e3bd22'/>
	<pointer-type-def type-id='37e3bd22' size-in-bits='64' id='03829398'/>
	<pointer-type-def type-id='a84c031d' size-in-bits='64' id='26a90f95'/>
	<pointer-type-def type-id='26a90f95' size-in-bits='64' id='9b23c9ad'/>
	<pointer-type-def type-id='9b23c9ad' size-in-bits='64' id='c0563f85'/>
	<qualified-type-def type-id='a84c031d' const='yes' id='9b45d938'/>
	<pointer-type-def type-id='9b45d938' size-in-bits='64' id='80f4b756'/>
	+ <qualified-type-def type-id='80f4b756' restrict='yes' id='9d26089a'/>
	<qualified-type-def type-id='aca3bac8' const='yes' id='2498fd78'/>
	<pointer-type-def type-id='2498fd78' size-in-bits='64' id='eed6c816'/>
	+ <qualified-type-def type-id='eed6c816' restrict='yes' id='a431a9da'/>
	<pointer-type-def type-id='a0eb0f08' size-in-bits='64' id='7408d286'/>
	<pointer-type-def type-id='cebdd548' size-in-bits='64' id='e379e62d'/>
	<pointer-type-def type-id='9f88f76e' size-in-bits='64' id='7ef0e988'/>
	<pointer-type-def type-id='c5bb1a2b' size-in-bits='64' id='c0d0f877'/>
	<pointer-type-def type-id='573fea1b' size-in-bits='64' id='de20bf07'/>
	<pointer-type-def type-id='70284cc6' size-in-bits='64' id='3be4d568'/>
	<pointer-type-def type-id='700c3bca' size-in-bits='64' id='6d994334'/>
	<pointer-type-def type-id='18ac1860' size-in-bits='64' id='506ab59a'/>
	<pointer-type-def type-id='328fee42' size-in-bits='64' id='750cc41c'/>
	<pointer-type-def type-id='7ba5cd31' size-in-bits='64' id='aaea91b5'/>
	<pointer-type-def type-id='a86d8029' size-in-bits='64' id='42257af5'/>
	<pointer-type-def type-id='0b4eb914' size-in-bits='64' id='19ea27ae'/>
	<pointer-type-def type-id='c6c8144e' size-in-bits='64' id='2835af80'/>
	<pointer-type-def type-id='20f7b475' size-in-bits='64' id='6a2f50c1'/>
	<pointer-type-def type-id='102ee17a' size-in-bits='64' id='e1c54c3c'/>
	<pointer-type-def type-id='49b69c77' size-in-bits='64' id='ea6be4eb'/>
	<pointer-type-def type-id='cb5d50f1' size-in-bits='64' id='1708018d'/>
	<pointer-type-def type-id='880d56b8' size-in-bits='64' id='d2af7f32'/>
	<pointer-type-def type-id='a739bfc6' size-in-bits='64' id='506696a8'/>
	<pointer-type-def type-id='234f35e8' size-in-bits='64' id='8a1fb33a'/>
	<pointer-type-def type-id='41f7168a' size-in-bits='64' id='f10f1e84'/>
	<pointer-type-def type-id='e8d6e508' size-in-bits='64' id='90174072'/>
	<pointer-type-def type-id='f3daafe5' size-in-bits='64' id='0b22f759'/>
	<pointer-type-def type-id='17ab04ad' size-in-bits='64' id='39b623f9'/>
	<pointer-type-def type-id='256cdd75' size-in-bits='64' id='7391ed39'/>
	<pointer-type-def type-id='cc10a041' size-in-bits='64' id='ed6a3a3d'/>
	<pointer-type-def type-id='9fd269d3' size-in-bits='64' id='292cdbcf'/>
	<pointer-type-def type-id='3bd73b0c' size-in-bits='64' id='7e85a9b6'/>
	<pointer-type-def type-id='0d445e26' size-in-bits='64' id='330cc0d0'/>
	<pointer-type-def type-id='e4b89f30' size-in-bits='64' id='ed8aa8ba'/>
	<pointer-type-def type-id='be7f4941' size-in-bits='64' id='2809de35'/>
	<pointer-type-def type-id='fe5ae69d' size-in-bits='64' id='90d5edb9'/>
	<pointer-type-def type-id='2783af3c' size-in-bits='64' id='e44553b6'/>
	<pointer-type-def type-id='33c6e3d8' size-in-bits='64' id='1263777a'/>
	<pointer-type-def type-id='dadb9eca' size-in-bits='64' id='cbda43ac'/>
	<pointer-type-def type-id='55b9e070' size-in-bits='64' id='b3fae562'/>
	<pointer-type-def type-id='8e63c78b' size-in-bits='64' id='8b41e457'/>
	<pointer-type-def type-id='c542ed33' size-in-bits='64' id='f9668a57'/>
	<pointer-type-def type-id='5dea179a' size-in-bits='64' id='001d8764'/>
	<pointer-type-def type-id='b6f659a0' size-in-bits='64' id='44f188f2'/>
	<pointer-type-def type-id='2765bd17' size-in-bits='64' id='976f721b'/>
	<pointer-type-def type-id='9e073b5c' size-in-bits='64' id='ee62ad8e'/>
	<pointer-type-def type-id='2c785071' size-in-bits='64' id='957d9f35'/>
	<pointer-type-def type-id='aad19bf7' size-in-bits='64' id='4db8acf3'/>
	<pointer-type-def type-id='0660e71a' size-in-bits='64' id='0ca7b13c'/>
	<pointer-type-def type-id='250287b8' size-in-bits='64' id='a91bad5a'/>
	<pointer-type-def type-id='e7344862' size-in-bits='64' id='519bf35c'/>
	<pointer-type-def type-id='32b6d968' size-in-bits='64' id='92988dea'/>
	<pointer-type-def type-id='5c975642' size-in-bits='64' id='7f8ee7e4'/>
	<pointer-type-def type-id='0155b993' size-in-bits='64' id='2c8c4457'/>
	<pointer-type-def type-id='6e8b02cb' size-in-bits='64' id='eb944897'/>
	<pointer-type-def type-id='d434b7d7' size-in-bits='64' id='108e6453'/>
	<pointer-type-def type-id='c645e10f' size-in-bits='64' id='5cbe16ab'/>
	<pointer-type-def type-id='de41f295' size-in-bits='64' id='d94cdfa1'/>
	<pointer-type-def type-id='b2fbf64a' size-in-bits='64' id='470a7fd4'/>
	<pointer-type-def type-id='cc22d314' size-in-bits='64' id='eddda806'/>
	<pointer-type-def type-id='23bd8cb5' size-in-bits='64' id='f76f73d0'/>
	<pointer-type-def type-id='f76f73d0' size-in-bits='64' id='7e73928e'/>
	<pointer-type-def type-id='3ff5601b' size-in-bits='64' id='4aafb922'/>
	<pointer-type-def type-id='4aafb922' size-in-bits='64' id='9aa04798'/>
	<pointer-type-def type-id='9da381c4' size-in-bits='64' id='cb785ebf'/>
	<pointer-type-def type-id='cb785ebf' size-in-bits='64' id='e37ce48f'/>
	<pointer-type-def type-id='ee31ee44' size-in-bits='64' id='256d5229'/>
	<pointer-type-def type-id='256d5229' size-in-bits='64' id='ee181ab9'/>
	<pointer-type-def type-id='ebc6735b' size-in-bits='64' id='7be54adb'/>
	<pointer-type-def type-id='d2e8bad9' size-in-bits='64' id='196db161'/>
	<pointer-type-def type-id='8e8d4be3' size-in-bits='64' id='5ce45b60'/>
	<pointer-type-def type-id='5ce45b60' size-in-bits='64' id='857bb57e'/>
	<pointer-type-def type-id='857bb57e' size-in-bits='64' id='75be733c'/>
	<pointer-type-def type-id='57928edf' size-in-bits='64' id='3fa542f0'/>
	+ <pointer-type-def type-id='b48d2441' size-in-bits='64' id='33976309'/>
	<pointer-type-def type-id='aca3bac8' size-in-bits='64' id='d33f11cb'/>
	<pointer-type-def type-id='1b941664' size-in-bits='64' id='7e2979d5'/>
	+ <qualified-type-def type-id='7e2979d5' restrict='yes' id='fc212857'/>
	<pointer-type-def type-id='d8bf0010' size-in-bits='64' id='45b65157'/>
	<pointer-type-def type-id='45b65157' size-in-bits='64' id='3b0247c7'/>
	<pointer-type-def type-id='149c6638' size-in-bits='64' id='8a121f49'/>
	<pointer-type-def type-id='8a121f49' size-in-bits='64' id='bd8768d9'/>
	<pointer-type-def type-id='8f92235e' size-in-bits='64' id='90421557'/>
	<pointer-type-def type-id='90421557' size-in-bits='64' id='9507d3c7'/>
	<pointer-type-def type-id='9c313c2d' size-in-bits='64' id='5d6479ae'/>
	<pointer-type-def type-id='5d6479ae' size-in-bits='64' id='892b4acc'/>
	<pointer-type-def type-id='b96825af' size-in-bits='64' id='ae3e8ca6'/>
	<pointer-type-def type-id='ae3e8ca6' size-in-bits='64' id='d8774064'/>
	<pointer-type-def type-id='3502e3ff' size-in-bits='64' id='4dd26a40'/>
	<pointer-type-def type-id='002ac4a6' size-in-bits='64' id='cf536864'/>
	<pointer-type-def type-id='48b5725f' size-in-bits='64' id='eaa32e2f'/>
	+ <class-decl name='_IO_codecvt' is-struct='yes' visibility='default' is-declaration-only='yes' id='a4036571'/>
	+ <class-decl name='_IO_marker' is-struct='yes' visibility='default' is-declaration-only='yes' id='010ae0b9'/>
	+ <class-decl name='_IO_wide_data' is-struct='yes' visibility='default' is-declaration-only='yes' id='79bd3751'/>
	+ <class-decl name='re_dfa_t' is-struct='yes' visibility='default' is-declaration-only='yes' id='b48d2441'/>
	+ <function-decl name='nvlist_next_nvpair' mangled-name='nvlist_next_nvpair' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_next_nvpair'>
	+ <parameter type-id='5ce45b60'/>
	+ <parameter type-id='3fa542f0'/>
	+ <return type-id='3fa542f0'/>
	+ </function-decl>
	+ <function-decl name='nvpair_name' mangled-name='nvpair_name' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvpair_name'>
	+ <parameter type-id='3fa542f0'/>
	+ <return type-id='26a90f95'/>
	+ </function-decl>
	+ <function-decl name='nvpair_type' mangled-name='nvpair_type' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvpair_type'>
	+ <parameter type-id='3fa542f0'/>
	+ <return type-id='8d0687d2'/>
	+ </function-decl>
	+ <function-decl name='nvpair_type_is_array' mangled-name='nvpair_type_is_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvpair_type_is_array'>
	+ <parameter type-id='3fa542f0'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='nvpair_value_boolean_value' mangled-name='nvpair_value_boolean_value' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvpair_value_boolean_value'>
	+ <parameter type-id='3fa542f0'/>
	+ <parameter type-id='37e3bd22'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='nvpair_value_byte' mangled-name='nvpair_value_byte' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvpair_value_byte'>
	+ <parameter type-id='3fa542f0'/>
	+ <parameter type-id='45b65157'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='nvpair_value_int8' mangled-name='nvpair_value_int8' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvpair_value_int8'>
	+ <parameter type-id='3fa542f0'/>
	+ <parameter type-id='256d5229'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='nvpair_value_uint8' mangled-name='nvpair_value_uint8' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvpair_value_uint8'>
	+ <parameter type-id='3fa542f0'/>
	+ <parameter type-id='ae3e8ca6'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='nvpair_value_int16' mangled-name='nvpair_value_int16' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvpair_value_int16'>
	+ <parameter type-id='3fa542f0'/>
	+ <parameter type-id='f76f73d0'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='nvpair_value_uint16' mangled-name='nvpair_value_uint16' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvpair_value_uint16'>
	+ <parameter type-id='3fa542f0'/>
	+ <parameter type-id='8a121f49'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='nvpair_value_int32' mangled-name='nvpair_value_int32' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvpair_value_int32'>
	+ <parameter type-id='3fa542f0'/>
	+ <parameter type-id='4aafb922'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='nvpair_value_uint32' mangled-name='nvpair_value_uint32' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvpair_value_uint32'>
	+ <parameter type-id='3fa542f0'/>
	+ <parameter type-id='90421557'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='nvpair_value_int64' mangled-name='nvpair_value_int64' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvpair_value_int64'>
	+ <parameter type-id='3fa542f0'/>
	+ <parameter type-id='cb785ebf'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='nvpair_value_uint64' mangled-name='nvpair_value_uint64' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvpair_value_uint64'>
	+ <parameter type-id='3fa542f0'/>
	+ <parameter type-id='5d6479ae'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='nvpair_value_string' mangled-name='nvpair_value_string' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvpair_value_string'>
	+ <parameter type-id='3fa542f0'/>
	+ <parameter type-id='9b23c9ad'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='nvpair_value_nvlist' mangled-name='nvpair_value_nvlist' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvpair_value_nvlist'>
	+ <parameter type-id='3fa542f0'/>
	+ <parameter type-id='857bb57e'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='nvpair_value_boolean_array' mangled-name='nvpair_value_boolean_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvpair_value_boolean_array'>
	+ <parameter type-id='3fa542f0'/>
	+ <parameter type-id='03829398'/>
	+ <parameter type-id='4dd26a40'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='nvpair_value_byte_array' mangled-name='nvpair_value_byte_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvpair_value_byte_array'>
	+ <parameter type-id='3fa542f0'/>
	+ <parameter type-id='3b0247c7'/>
	+ <parameter type-id='4dd26a40'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='nvpair_value_int8_array' mangled-name='nvpair_value_int8_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvpair_value_int8_array'>
	+ <parameter type-id='3fa542f0'/>
	+ <parameter type-id='ee181ab9'/>
	+ <parameter type-id='4dd26a40'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='nvpair_value_uint8_array' mangled-name='nvpair_value_uint8_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvpair_value_uint8_array'>
	+ <parameter type-id='3fa542f0'/>
	+ <parameter type-id='d8774064'/>
	+ <parameter type-id='4dd26a40'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='nvpair_value_int16_array' mangled-name='nvpair_value_int16_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvpair_value_int16_array'>
	+ <parameter type-id='3fa542f0'/>
	+ <parameter type-id='7e73928e'/>
	+ <parameter type-id='4dd26a40'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='nvpair_value_uint16_array' mangled-name='nvpair_value_uint16_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvpair_value_uint16_array'>
	+ <parameter type-id='3fa542f0'/>
	+ <parameter type-id='bd8768d9'/>
	+ <parameter type-id='4dd26a40'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='nvpair_value_int32_array' mangled-name='nvpair_value_int32_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvpair_value_int32_array'>
	+ <parameter type-id='3fa542f0'/>
	+ <parameter type-id='9aa04798'/>
	+ <parameter type-id='4dd26a40'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='nvpair_value_uint32_array' mangled-name='nvpair_value_uint32_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvpair_value_uint32_array'>
	+ <parameter type-id='3fa542f0'/>
	+ <parameter type-id='9507d3c7'/>
	+ <parameter type-id='4dd26a40'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='nvpair_value_int64_array' mangled-name='nvpair_value_int64_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvpair_value_int64_array'>
	+ <parameter type-id='3fa542f0'/>
	+ <parameter type-id='e37ce48f'/>
	+ <parameter type-id='4dd26a40'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='nvpair_value_uint64_array' mangled-name='nvpair_value_uint64_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvpair_value_uint64_array'>
	+ <parameter type-id='3fa542f0'/>
	+ <parameter type-id='892b4acc'/>
	+ <parameter type-id='4dd26a40'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='nvpair_value_string_array' mangled-name='nvpair_value_string_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvpair_value_string_array'>
	+ <parameter type-id='3fa542f0'/>
	+ <parameter type-id='c0563f85'/>
	+ <parameter type-id='4dd26a40'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='nvpair_value_nvlist_array' mangled-name='nvpair_value_nvlist_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvpair_value_nvlist_array'>
	+ <parameter type-id='3fa542f0'/>
	+ <parameter type-id='75be733c'/>
	+ <parameter type-id='4dd26a40'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='nvpair_value_hrtime' mangled-name='nvpair_value_hrtime' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvpair_value_hrtime'>
	+ <parameter type-id='3fa542f0'/>
	+ <parameter type-id='e379e62d'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='nvpair_value_double' mangled-name='nvpair_value_double' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvpair_value_double'>
	+ <parameter type-id='3fa542f0'/>
	+ <parameter type-id='7408d286'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	<function-decl name='nvlist_prtctl_setdest' mangled-name='nvlist_prtctl_setdest' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_prtctl_setdest'>
	<parameter type-id='b0c1ff8d' name='pctl'/>
	<parameter type-id='822cd80b' name='fp'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='nvlist_prtctl_getdest' mangled-name='nvlist_prtctl_getdest' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_prtctl_getdest'>
	<parameter type-id='b0c1ff8d' name='pctl'/>
	<return type-id='822cd80b'/>
	</function-decl>
	<function-decl name='nvlist_prtctl_setindent' mangled-name='nvlist_prtctl_setindent' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_prtctl_setindent'>
	<parameter type-id='b0c1ff8d' name='pctl'/>
	<parameter type-id='628aafab' name='mode'/>
	<parameter type-id='95e97e5e' name='start'/>
	<parameter type-id='95e97e5e' name='inc'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='nvlist_prtctl_doindent' mangled-name='nvlist_prtctl_doindent' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_prtctl_doindent'>
	<parameter type-id='b0c1ff8d' name='pctl'/>
	<parameter type-id='95e97e5e' name='onemore'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='nvlist_prtctl_setfmt' mangled-name='nvlist_prtctl_setfmt' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_prtctl_setfmt'>
	<parameter type-id='b0c1ff8d' name='pctl'/>
	<parameter type-id='c8dcc53a' name='which'/>
	<parameter type-id='80f4b756' name='fmt'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='nvlist_prtctl_dofmt' mangled-name='nvlist_prtctl_dofmt' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_prtctl_dofmt'>
	<parameter type-id='b0c1ff8d' name='pctl'/>
	<parameter type-id='c8dcc53a' name='which'/>
	<parameter is-variadic='yes'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='nvlist_prtctlop_boolean' mangled-name='nvlist_prtctlop_boolean' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_prtctlop_boolean'>
	<parameter type-id='b0c1ff8d' name='pctl'/>
	<parameter type-id='1263777a' name='func'/>
	<parameter type-id='eaa32e2f' name='private'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='nvlist_prtctlop_boolean_value' mangled-name='nvlist_prtctlop_boolean_value' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_prtctlop_boolean_value'>
	<parameter type-id='b0c1ff8d' name='pctl'/>
	<parameter type-id='976f721b' name='func'/>
	<parameter type-id='eaa32e2f' name='private'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='nvlist_prtctlop_byte' mangled-name='nvlist_prtctlop_byte' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_prtctlop_byte'>
	<parameter type-id='b0c1ff8d' name='pctl'/>
	<parameter type-id='519bf35c' name='func'/>
	<parameter type-id='eaa32e2f' name='private'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='nvlist_prtctlop_int8' mangled-name='nvlist_prtctlop_int8' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_prtctlop_int8'>
	<parameter type-id='b0c1ff8d' name='pctl'/>
	<parameter type-id='a91bad5a' name='func'/>
	<parameter type-id='eaa32e2f' name='private'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='nvlist_prtctlop_uint8' mangled-name='nvlist_prtctlop_uint8' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_prtctlop_uint8'>
	<parameter type-id='b0c1ff8d' name='pctl'/>
	<parameter type-id='eb944897' name='func'/>
	<parameter type-id='eaa32e2f' name='private'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='nvlist_prtctlop_int16' mangled-name='nvlist_prtctlop_int16' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_prtctlop_int16'>
	<parameter type-id='b0c1ff8d' name='pctl'/>
	<parameter type-id='957d9f35' name='func'/>
	<parameter type-id='eaa32e2f' name='private'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='nvlist_prtctlop_uint16' mangled-name='nvlist_prtctlop_uint16' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_prtctlop_uint16'>
	<parameter type-id='b0c1ff8d' name='pctl'/>
	<parameter type-id='92988dea' name='func'/>
	<parameter type-id='eaa32e2f' name='private'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='nvlist_prtctlop_int32' mangled-name='nvlist_prtctlop_int32' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_prtctlop_int32'>
	<parameter type-id='b0c1ff8d' name='pctl'/>
	<parameter type-id='4db8acf3' name='func'/>
	<parameter type-id='eaa32e2f' name='private'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='nvlist_prtctlop_uint32' mangled-name='nvlist_prtctlop_uint32' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_prtctlop_uint32'>
	<parameter type-id='b0c1ff8d' name='pctl'/>
	<parameter type-id='7f8ee7e4' name='func'/>
	<parameter type-id='eaa32e2f' name='private'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='nvlist_prtctlop_int64' mangled-name='nvlist_prtctlop_int64' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_prtctlop_int64'>
	<parameter type-id='b0c1ff8d' name='pctl'/>
	<parameter type-id='0ca7b13c' name='func'/>
	<parameter type-id='eaa32e2f' name='private'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='nvlist_prtctlop_uint64' mangled-name='nvlist_prtctlop_uint64' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_prtctlop_uint64'>
	<parameter type-id='b0c1ff8d' name='pctl'/>
	<parameter type-id='2c8c4457' name='func'/>
	<parameter type-id='eaa32e2f' name='private'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='nvlist_prtctlop_double' mangled-name='nvlist_prtctlop_double' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_prtctlop_double'>
	<parameter type-id='b0c1ff8d' name='pctl'/>
	<parameter type-id='e44553b6' name='func'/>
	<parameter type-id='eaa32e2f' name='private'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='nvlist_prtctlop_string' mangled-name='nvlist_prtctlop_string' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_prtctlop_string'>
	<parameter type-id='b0c1ff8d' name='pctl'/>
	<parameter type-id='2809de35' name='func'/>
	<parameter type-id='eaa32e2f' name='private'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='nvlist_prtctlop_hrtime' mangled-name='nvlist_prtctlop_hrtime' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_prtctlop_hrtime'>
	<parameter type-id='b0c1ff8d' name='pctl'/>
	<parameter type-id='ee62ad8e' name='func'/>
	<parameter type-id='eaa32e2f' name='private'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='nvlist_prtctlop_nvlist' mangled-name='nvlist_prtctlop_nvlist' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_prtctlop_nvlist'>
	<parameter type-id='b0c1ff8d' name='pctl'/>
	<parameter type-id='001d8764' name='func'/>
	<parameter type-id='eaa32e2f' name='private'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='nvlist_prtctlop_boolean_array' mangled-name='nvlist_prtctlop_boolean_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_prtctlop_boolean_array'>
	<parameter type-id='b0c1ff8d' name='pctl'/>
	<parameter type-id='ed8aa8ba' name='func'/>
	<parameter type-id='eaa32e2f' name='private'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='nvlist_prtctlop_byte_array' mangled-name='nvlist_prtctlop_byte_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_prtctlop_byte_array'>
	<parameter type-id='b0c1ff8d' name='pctl'/>
	<parameter type-id='108e6453' name='func'/>
	<parameter type-id='eaa32e2f' name='private'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='nvlist_prtctlop_int8_array' mangled-name='nvlist_prtctlop_int8_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_prtctlop_int8_array'>
	<parameter type-id='b0c1ff8d' name='pctl'/>
	<parameter type-id='f9668a57' name='func'/>
	<parameter type-id='eaa32e2f' name='private'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='nvlist_prtctlop_uint8_array' mangled-name='nvlist_prtctlop_uint8_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_prtctlop_uint8_array'>
	<parameter type-id='b0c1ff8d' name='pctl'/>
	<parameter type-id='eddda806' name='func'/>
	<parameter type-id='eaa32e2f' name='private'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='nvlist_prtctlop_int16_array' mangled-name='nvlist_prtctlop_int16_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_prtctlop_int16_array'>
	<parameter type-id='b0c1ff8d' name='pctl'/>
	<parameter type-id='cbda43ac' name='func'/>
	<parameter type-id='eaa32e2f' name='private'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='nvlist_prtctlop_uint16_array' mangled-name='nvlist_prtctlop_uint16_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_prtctlop_uint16_array'>
	<parameter type-id='b0c1ff8d' name='pctl'/>
	<parameter type-id='5cbe16ab' name='func'/>
	<parameter type-id='eaa32e2f' name='private'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='nvlist_prtctlop_int32_array' mangled-name='nvlist_prtctlop_int32_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_prtctlop_int32_array'>
	<parameter type-id='b0c1ff8d' name='pctl'/>
	<parameter type-id='b3fae562' name='func'/>
	- <parameter type-id='eaa32e2f' name='private'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	- <function-decl name='nvlist_prtctlop_uint32_array' mangled-name='nvlist_prtctlop_uint32_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_prtctlop_uint32_array'>
	- <parameter type-id='b0c1ff8d' name='pctl'/>
	- <parameter type-id='d94cdfa1' name='func'/>
	- <parameter type-id='eaa32e2f' name='private'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	- <function-decl name='nvlist_prtctlop_int64_array' mangled-name='nvlist_prtctlop_int64_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_prtctlop_int64_array'>
	- <parameter type-id='b0c1ff8d' name='pctl'/>
	- <parameter type-id='8b41e457' name='func'/>
	- <parameter type-id='eaa32e2f' name='private'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	- <function-decl name='nvlist_prtctlop_uint64_array' mangled-name='nvlist_prtctlop_uint64_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_prtctlop_uint64_array'>
	- <parameter type-id='b0c1ff8d' name='pctl'/>
	- <parameter type-id='470a7fd4' name='func'/>
	- <parameter type-id='eaa32e2f' name='private'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	- <function-decl name='nvlist_prtctlop_string_array' mangled-name='nvlist_prtctlop_string_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_prtctlop_string_array'>
	- <parameter type-id='b0c1ff8d' name='pctl'/>
	- <parameter type-id='90d5edb9' name='func'/>
	- <parameter type-id='eaa32e2f' name='private'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	- <function-decl name='nvlist_prtctlop_nvlist_array' mangled-name='nvlist_prtctlop_nvlist_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_prtctlop_nvlist_array'>
	- <parameter type-id='b0c1ff8d' name='pctl'/>
	- <parameter type-id='44f188f2' name='func'/>
	- <parameter type-id='eaa32e2f' name='private'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	- <function-decl name='nvlist_prtctl_alloc' mangled-name='nvlist_prtctl_alloc' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_prtctl_alloc'>
	- <return type-id='b0c1ff8d'/>
	- </function-decl>
	- <function-decl name='nvlist_prtctl_free' mangled-name='nvlist_prtctl_free' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_prtctl_free'>
	- <parameter type-id='b0c1ff8d' name='pctl'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	- <function-decl name='nvlist_print' mangled-name='nvlist_print' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_print'>
	- <parameter type-id='822cd80b' name='fp'/>
	- <parameter type-id='5ce45b60' name='nvl'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	- <function-decl name='nvlist_prt' mangled-name='nvlist_prt' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_prt'>
	- <parameter type-id='5ce45b60' name='nvl'/>
	- <parameter type-id='b0c1ff8d' name='pctl'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	- <function-decl name='dump_nvlist' mangled-name='dump_nvlist' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='dump_nvlist'>
	- <parameter type-id='5ce45b60' name='list'/>
	- <parameter type-id='95e97e5e' name='indent'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	- <function-decl name='nvpair_value_match_regex' mangled-name='nvpair_value_match_regex' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvpair_value_match_regex'>
	- <parameter type-id='3fa542f0' name='nvp'/>
	- <parameter type-id='95e97e5e' name='ai'/>
	- <parameter type-id='26a90f95' name='value'/>
	- <parameter type-id='d33f11cb' name='value_regex'/>
	- <parameter type-id='9b23c9ad' name='ep'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='nvpair_value_match' mangled-name='nvpair_value_match' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvpair_value_match'>
	- <parameter type-id='3fa542f0' name='nvp'/>
	- <parameter type-id='95e97e5e' name='ai'/>
	- <parameter type-id='26a90f95' name='value'/>
	- <parameter type-id='9b23c9ad' name='ep'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='fprintf' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='822cd80b'/>
	- <parameter type-id='80f4b756'/>
	- <parameter is-variadic='yes'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='nvpair_value_nvlist_array' mangled-name='nvpair_value_nvlist_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvpair_value_nvlist_array'>
	- <parameter type-id='3fa542f0'/>
	- <parameter type-id='75be733c'/>
	- <parameter type-id='4dd26a40'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='nvpair_value_double' mangled-name='nvpair_value_double' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvpair_value_double'>
	- <parameter type-id='3fa542f0'/>
	- <parameter type-id='7408d286'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='nvpair_value_uint8_array' mangled-name='nvpair_value_uint8_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvpair_value_uint8_array'>
	- <parameter type-id='3fa542f0'/>
	- <parameter type-id='d8774064'/>
	- <parameter type-id='4dd26a40'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='nvpair_value_int8_array' mangled-name='nvpair_value_int8_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvpair_value_int8_array'>
	- <parameter type-id='3fa542f0'/>
	- <parameter type-id='ee181ab9'/>
	- <parameter type-id='4dd26a40'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='nvpair_value_boolean_array' mangled-name='nvpair_value_boolean_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvpair_value_boolean_array'>
	- <parameter type-id='3fa542f0'/>
	- <parameter type-id='03829398'/>
	- <parameter type-id='4dd26a40'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='nvpair_value_uint8' mangled-name='nvpair_value_uint8' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvpair_value_uint8'>
	- <parameter type-id='3fa542f0'/>
	- <parameter type-id='ae3e8ca6'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='nvpair_value_int8' mangled-name='nvpair_value_int8' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvpair_value_int8'>
	- <parameter type-id='3fa542f0'/>
	- <parameter type-id='256d5229'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='nvpair_value_boolean_value' mangled-name='nvpair_value_boolean_value' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvpair_value_boolean_value'>
	- <parameter type-id='3fa542f0'/>
	- <parameter type-id='37e3bd22'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='nvpair_value_nvlist' mangled-name='nvpair_value_nvlist' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvpair_value_nvlist'>
	- <parameter type-id='3fa542f0'/>
	- <parameter type-id='857bb57e'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='nvpair_value_hrtime' mangled-name='nvpair_value_hrtime' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvpair_value_hrtime'>
	- <parameter type-id='3fa542f0'/>
	- <parameter type-id='e379e62d'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='nvpair_value_string_array' mangled-name='nvpair_value_string_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvpair_value_string_array'>
	- <parameter type-id='3fa542f0'/>
	- <parameter type-id='c0563f85'/>
	- <parameter type-id='4dd26a40'/>
	- <return type-id='95e97e5e'/>
	+ <parameter type-id='eaa32e2f' name='private'/>
	+ <return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='nvpair_value_uint64_array' mangled-name='nvpair_value_uint64_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvpair_value_uint64_array'>
	- <parameter type-id='3fa542f0'/>
	- <parameter type-id='892b4acc'/>
	- <parameter type-id='4dd26a40'/>
	- <return type-id='95e97e5e'/>
	+ <function-decl name='nvlist_prtctlop_uint32_array' mangled-name='nvlist_prtctlop_uint32_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_prtctlop_uint32_array'>
	+ <parameter type-id='b0c1ff8d' name='pctl'/>
	+ <parameter type-id='d94cdfa1' name='func'/>
	+ <parameter type-id='eaa32e2f' name='private'/>
	+ <return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='nvpair_value_int64_array' mangled-name='nvpair_value_int64_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvpair_value_int64_array'>
	- <parameter type-id='3fa542f0'/>
	- <parameter type-id='e37ce48f'/>
	- <parameter type-id='4dd26a40'/>
	- <return type-id='95e97e5e'/>
	+ <function-decl name='nvlist_prtctlop_int64_array' mangled-name='nvlist_prtctlop_int64_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_prtctlop_int64_array'>
	+ <parameter type-id='b0c1ff8d' name='pctl'/>
	+ <parameter type-id='8b41e457' name='func'/>
	+ <parameter type-id='eaa32e2f' name='private'/>
	+ <return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='nvpair_value_uint32_array' mangled-name='nvpair_value_uint32_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvpair_value_uint32_array'>
	- <parameter type-id='3fa542f0'/>
	- <parameter type-id='9507d3c7'/>
	- <parameter type-id='4dd26a40'/>
	- <return type-id='95e97e5e'/>
	+ <function-decl name='nvlist_prtctlop_uint64_array' mangled-name='nvlist_prtctlop_uint64_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_prtctlop_uint64_array'>
	+ <parameter type-id='b0c1ff8d' name='pctl'/>
	+ <parameter type-id='470a7fd4' name='func'/>
	+ <parameter type-id='eaa32e2f' name='private'/>
	+ <return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='nvpair_value_int32_array' mangled-name='nvpair_value_int32_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvpair_value_int32_array'>
	- <parameter type-id='3fa542f0'/>
	- <parameter type-id='9aa04798'/>
	- <parameter type-id='4dd26a40'/>
	- <return type-id='95e97e5e'/>
	+ <function-decl name='nvlist_prtctlop_string_array' mangled-name='nvlist_prtctlop_string_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_prtctlop_string_array'>
	+ <parameter type-id='b0c1ff8d' name='pctl'/>
	+ <parameter type-id='90d5edb9' name='func'/>
	+ <parameter type-id='eaa32e2f' name='private'/>
	+ <return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='nvpair_value_uint16_array' mangled-name='nvpair_value_uint16_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvpair_value_uint16_array'>
	- <parameter type-id='3fa542f0'/>
	- <parameter type-id='bd8768d9'/>
	- <parameter type-id='4dd26a40'/>
	- <return type-id='95e97e5e'/>
	+ <function-decl name='nvlist_prtctlop_nvlist_array' mangled-name='nvlist_prtctlop_nvlist_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_prtctlop_nvlist_array'>
	+ <parameter type-id='b0c1ff8d' name='pctl'/>
	+ <parameter type-id='44f188f2' name='func'/>
	+ <parameter type-id='eaa32e2f' name='private'/>
	+ <return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='nvpair_value_int16_array' mangled-name='nvpair_value_int16_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvpair_value_int16_array'>
	- <parameter type-id='3fa542f0'/>
	- <parameter type-id='7e73928e'/>
	- <parameter type-id='4dd26a40'/>
	- <return type-id='95e97e5e'/>
	+ <function-decl name='nvlist_prtctl_alloc' mangled-name='nvlist_prtctl_alloc' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_prtctl_alloc'>
	+ <return type-id='b0c1ff8d'/>
	</function-decl>
	- <function-decl name='nvpair_value_byte_array' mangled-name='nvpair_value_byte_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvpair_value_byte_array'>
	- <parameter type-id='3fa542f0'/>
	- <parameter type-id='3b0247c7'/>
	- <parameter type-id='4dd26a40'/>
	- <return type-id='95e97e5e'/>
	+ <function-decl name='nvlist_prtctl_free' mangled-name='nvlist_prtctl_free' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_prtctl_free'>
	+ <parameter type-id='b0c1ff8d' name='pctl'/>
	+ <return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='nvpair_value_string' mangled-name='nvpair_value_string' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvpair_value_string'>
	- <parameter type-id='3fa542f0'/>
	- <parameter type-id='9b23c9ad'/>
	- <return type-id='95e97e5e'/>
	+ <function-decl name='nvlist_print' mangled-name='nvlist_print' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_print'>
	+ <parameter type-id='822cd80b' name='fp'/>
	+ <parameter type-id='5ce45b60' name='nvl'/>
	+ <return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='nvpair_value_uint64' mangled-name='nvpair_value_uint64' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvpair_value_uint64'>
	- <parameter type-id='3fa542f0'/>
	- <parameter type-id='5d6479ae'/>
	- <return type-id='95e97e5e'/>
	+ <function-decl name='nvlist_prt' mangled-name='nvlist_prt' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_prt'>
	+ <parameter type-id='5ce45b60' name='nvl'/>
	+ <parameter type-id='b0c1ff8d' name='pctl'/>
	+ <return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='nvpair_value_int64' mangled-name='nvpair_value_int64' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvpair_value_int64'>
	- <parameter type-id='3fa542f0'/>
	- <parameter type-id='cb785ebf'/>
	- <return type-id='95e97e5e'/>
	+ <function-decl name='dump_nvlist' mangled-name='dump_nvlist' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='dump_nvlist'>
	+ <parameter type-id='5ce45b60' name='list'/>
	+ <parameter type-id='95e97e5e' name='indent'/>
	+ <return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='nvpair_value_uint32' mangled-name='nvpair_value_uint32' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvpair_value_uint32'>
	- <parameter type-id='3fa542f0'/>
	- <parameter type-id='90421557'/>
	+ <function-decl name='nvpair_value_match_regex' mangled-name='nvpair_value_match_regex' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvpair_value_match_regex'>
	+ <parameter type-id='3fa542f0' name='nvp'/>
	+ <parameter type-id='95e97e5e' name='ai'/>
	+ <parameter type-id='26a90f95' name='value'/>
	+ <parameter type-id='d33f11cb' name='value_regex'/>
	+ <parameter type-id='9b23c9ad' name='ep'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='nvpair_value_int32' mangled-name='nvpair_value_int32' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvpair_value_int32'>
	- <parameter type-id='3fa542f0'/>
	- <parameter type-id='4aafb922'/>
	+ <function-decl name='nvpair_value_match' mangled-name='nvpair_value_match' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvpair_value_match'>
	+ <parameter type-id='3fa542f0' name='nvp'/>
	+ <parameter type-id='95e97e5e' name='ai'/>
	+ <parameter type-id='26a90f95' name='value'/>
	+ <parameter type-id='9b23c9ad' name='ep'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='nvpair_value_uint16' mangled-name='nvpair_value_uint16' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvpair_value_uint16'>
	- <parameter type-id='3fa542f0'/>
	- <parameter type-id='8a121f49'/>
	- <return type-id='95e97e5e'/>
	+ <function-decl name='dcgettext' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='95e97e5e'/>
	+ <return type-id='26a90f95'/>
	</function-decl>
	- <function-decl name='nvpair_value_int16' mangled-name='nvpair_value_int16' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvpair_value_int16'>
	- <parameter type-id='3fa542f0'/>
	- <parameter type-id='f76f73d0'/>
	+ <function-decl name='regexec' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='a431a9da'/>
	+ <parameter type-id='9d26089a'/>
	+ <parameter type-id='b59d7dce'/>
	+ <parameter type-id='fc212857'/>
	+ <parameter type-id='95e97e5e'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='nvpair_value_byte' mangled-name='nvpair_value_byte' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvpair_value_byte'>
	- <parameter type-id='3fa542f0'/>
	- <parameter type-id='45b65157'/>
	+ <function-decl name='fprintf' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='e75a27e9'/>
	+ <parameter type-id='9d26089a'/>
	+ <parameter is-variadic='yes'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='nvpair_type' mangled-name='nvpair_type' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvpair_type'>
	- <parameter type-id='3fa542f0'/>
	- <return type-id='8d0687d2'/>
	- </function-decl>
	- <function-decl name='nvpair_name' mangled-name='nvpair_name' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvpair_name'>
	- <parameter type-id='3fa542f0'/>
	- <return type-id='26a90f95'/>
	- </function-decl>
	- <function-decl name='nvlist_next_nvpair' mangled-name='nvlist_next_nvpair' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_next_nvpair'>
	- <parameter type-id='5ce45b60'/>
	- <parameter type-id='3fa542f0'/>
	- <return type-id='3fa542f0'/>
	+ <function-decl name='printf' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='80f4b756'/>
	+ <parameter is-variadic='yes'/>
	+ <return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='malloc' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='b59d7dce'/>
	<return type-id='eaa32e2f'/>
	</function-decl>
	<function-decl name='calloc' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='b59d7dce'/>
	<parameter type-id='b59d7dce'/>
	<return type-id='eaa32e2f'/>
	</function-decl>
	<function-decl name='free' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='eaa32e2f'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='printf' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='strcmp' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='80f4b756'/>
	<parameter type-id='80f4b756'/>
	- <parameter is-variadic='yes'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='dcgettext' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='strcspn' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='80f4b756'/>
	<parameter type-id='80f4b756'/>
	- <parameter type-id='95e97e5e'/>
	- <return type-id='26a90f95'/>
	+ <return type-id='b59d7dce'/>
	</function-decl>
	- <function-decl name='sscanf' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='80f4b756'/>
	+ <function-decl name='strspn' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='80f4b756'/>
	- <parameter is-variadic='yes'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='regexec' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='eed6c816'/>
	<parameter type-id='80f4b756'/>
	- <parameter type-id='b59d7dce'/>
	- <parameter type-id='7e2979d5'/>
	- <parameter type-id='95e97e5e'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='nvpair_type_is_array' mangled-name='nvpair_type_is_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvpair_type_is_array'>
	- <parameter type-id='3fa542f0'/>
	- <return type-id='95e97e5e'/>
	+ <return type-id='b59d7dce'/>
	</function-decl>
	<function-type size-in-bits='64' id='9f88f76e'>
	<parameter type-id='196db161'/>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='37e3bd22'/>
	<parameter type-id='3502e3ff'/>
	<return type-id='95e97e5e'/>
	</function-type>
	<function-type size-in-bits='64' id='c5bb1a2b'>
	<parameter type-id='196db161'/>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='26a90f95'/>
	<return type-id='95e97e5e'/>
	</function-type>
	<function-type size-in-bits='64' id='573fea1b'>
	<parameter type-id='196db161'/>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='9b23c9ad'/>
	<parameter type-id='3502e3ff'/>
	<return type-id='95e97e5e'/>
	</function-type>
	<function-type size-in-bits='64' id='70284cc6'>
	<parameter type-id='196db161'/>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='a0eb0f08'/>
	<return type-id='95e97e5e'/>
	</function-type>
	<function-type size-in-bits='64' id='700c3bca'>
	<parameter type-id='196db161'/>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='95e97e5e'/>
	<return type-id='95e97e5e'/>
	</function-type>
	<function-type size-in-bits='64' id='18ac1860'>
	<parameter type-id='196db161'/>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='f76f73d0'/>
	<parameter type-id='3502e3ff'/>
	<return type-id='95e97e5e'/>
	</function-type>
	<function-type size-in-bits='64' id='328fee42'>
	<parameter type-id='196db161'/>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='4aafb922'/>
	<parameter type-id='3502e3ff'/>
	<return type-id='95e97e5e'/>
	</function-type>
	<function-type size-in-bits='64' id='7ba5cd31'>
	<parameter type-id='196db161'/>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='cb785ebf'/>
	<parameter type-id='3502e3ff'/>
	<return type-id='95e97e5e'/>
	</function-type>
	<function-type size-in-bits='64' id='a86d8029'>
	<parameter type-id='196db161'/>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='256d5229'/>
	<parameter type-id='3502e3ff'/>
	<return type-id='95e97e5e'/>
	</function-type>
	<function-type size-in-bits='64' id='0b4eb914'>
	<parameter type-id='196db161'/>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='5ce45b60'/>
	<return type-id='95e97e5e'/>
	</function-type>
	<function-type size-in-bits='64' id='c6c8144e'>
	<parameter type-id='196db161'/>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='857bb57e'/>
	<parameter type-id='3502e3ff'/>
	<return type-id='95e97e5e'/>
	</function-type>
	<function-type size-in-bits='64' id='20f7b475'>
	<parameter type-id='196db161'/>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='c19b74c3'/>
	<return type-id='95e97e5e'/>
	</function-type>
	<function-type size-in-bits='64' id='102ee17a'>
	<parameter type-id='196db161'/>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='cebdd548'/>
	<return type-id='95e97e5e'/>
	</function-type>
	<function-type size-in-bits='64' id='49b69c77'>
	<parameter type-id='196db161'/>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='23bd8cb5'/>
	<return type-id='95e97e5e'/>
	</function-type>
	<function-type size-in-bits='64' id='cb5d50f1'>
	<parameter type-id='196db161'/>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='3ff5601b'/>
	<return type-id='95e97e5e'/>
	</function-type>
	<function-type size-in-bits='64' id='880d56b8'>
	<parameter type-id='196db161'/>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='9da381c4'/>
	<return type-id='95e97e5e'/>
	</function-type>
	<function-type size-in-bits='64' id='a739bfc6'>
	<parameter type-id='196db161'/>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='ee31ee44'/>
	<return type-id='95e97e5e'/>
	</function-type>
	<function-type size-in-bits='64' id='234f35e8'>
	<parameter type-id='196db161'/>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='d8bf0010'/>
	<return type-id='95e97e5e'/>
	</function-type>
	<function-type size-in-bits='64' id='41f7168a'>
	<parameter type-id='196db161'/>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='149c6638'/>
	<return type-id='95e97e5e'/>
	</function-type>
	<function-type size-in-bits='64' id='e8d6e508'>
	<parameter type-id='196db161'/>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='8f92235e'/>
	<return type-id='95e97e5e'/>
	</function-type>
	<function-type size-in-bits='64' id='f3daafe5'>
	<parameter type-id='196db161'/>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='9c313c2d'/>
	<return type-id='95e97e5e'/>
	</function-type>
	<function-type size-in-bits='64' id='17ab04ad'>
	<parameter type-id='196db161'/>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='b96825af'/>
	<return type-id='95e97e5e'/>
	</function-type>
	<function-type size-in-bits='64' id='256cdd75'>
	<parameter type-id='196db161'/>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='45b65157'/>
	<parameter type-id='3502e3ff'/>
	<return type-id='95e97e5e'/>
	</function-type>
	<function-type size-in-bits='64' id='cc10a041'>
	<parameter type-id='196db161'/>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='8a121f49'/>
	<parameter type-id='3502e3ff'/>
	<return type-id='95e97e5e'/>
	</function-type>
	<function-type size-in-bits='64' id='9fd269d3'>
	<parameter type-id='196db161'/>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='90421557'/>
	<parameter type-id='3502e3ff'/>
	<return type-id='95e97e5e'/>
	</function-type>
	<function-type size-in-bits='64' id='3bd73b0c'>
	<parameter type-id='196db161'/>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='5d6479ae'/>
	<parameter type-id='3502e3ff'/>
	<return type-id='95e97e5e'/>
	</function-type>
	<function-type size-in-bits='64' id='0d445e26'>
	<parameter type-id='196db161'/>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='ae3e8ca6'/>
	<parameter type-id='3502e3ff'/>
	<return type-id='95e97e5e'/>
	</function-type>
	<function-type size-in-bits='64' id='e4b89f30'>
	<parameter type-id='b0c1ff8d'/>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='37e3bd22'/>
	<parameter type-id='3502e3ff'/>
	<return type-id='95e97e5e'/>
	</function-type>
	<function-type size-in-bits='64' id='be7f4941'>
	<parameter type-id='b0c1ff8d'/>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='26a90f95'/>
	<return type-id='95e97e5e'/>
	</function-type>
	<function-type size-in-bits='64' id='fe5ae69d'>
	<parameter type-id='b0c1ff8d'/>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='9b23c9ad'/>
	<parameter type-id='3502e3ff'/>
	<return type-id='95e97e5e'/>
	</function-type>
	<function-type size-in-bits='64' id='2783af3c'>
	<parameter type-id='b0c1ff8d'/>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='a0eb0f08'/>
	<return type-id='95e97e5e'/>
	</function-type>
	<function-type size-in-bits='64' id='33c6e3d8'>
	<parameter type-id='b0c1ff8d'/>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='95e97e5e'/>
	<return type-id='95e97e5e'/>
	</function-type>
	<function-type size-in-bits='64' id='dadb9eca'>
	<parameter type-id='b0c1ff8d'/>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='f76f73d0'/>
	<parameter type-id='3502e3ff'/>
	<return type-id='95e97e5e'/>
	</function-type>
	<function-type size-in-bits='64' id='55b9e070'>
	<parameter type-id='b0c1ff8d'/>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='4aafb922'/>
	<parameter type-id='3502e3ff'/>
	<return type-id='95e97e5e'/>
	</function-type>
	<function-type size-in-bits='64' id='8e63c78b'>
	<parameter type-id='b0c1ff8d'/>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='cb785ebf'/>
	<parameter type-id='3502e3ff'/>
	<return type-id='95e97e5e'/>
	</function-type>
	<function-type size-in-bits='64' id='c542ed33'>
	<parameter type-id='b0c1ff8d'/>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='256d5229'/>
	<parameter type-id='3502e3ff'/>
	<return type-id='95e97e5e'/>
	</function-type>
	<function-type size-in-bits='64' id='5dea179a'>
	<parameter type-id='b0c1ff8d'/>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='5ce45b60'/>
	<return type-id='95e97e5e'/>
	</function-type>
	<function-type size-in-bits='64' id='b6f659a0'>
	<parameter type-id='b0c1ff8d'/>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='857bb57e'/>
	<parameter type-id='3502e3ff'/>
	<return type-id='95e97e5e'/>
	</function-type>
	<function-type size-in-bits='64' id='2765bd17'>
	<parameter type-id='b0c1ff8d'/>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='c19b74c3'/>
	<return type-id='95e97e5e'/>
	</function-type>
	<function-type size-in-bits='64' id='9e073b5c'>
	<parameter type-id='b0c1ff8d'/>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='cebdd548'/>
	<return type-id='95e97e5e'/>
	</function-type>
	<function-type size-in-bits='64' id='2c785071'>
	<parameter type-id='b0c1ff8d'/>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='23bd8cb5'/>
	<return type-id='95e97e5e'/>
	</function-type>
	<function-type size-in-bits='64' id='aad19bf7'>
	<parameter type-id='b0c1ff8d'/>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='3ff5601b'/>
	<return type-id='95e97e5e'/>
	</function-type>
	<function-type size-in-bits='64' id='0660e71a'>
	<parameter type-id='b0c1ff8d'/>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='9da381c4'/>
	<return type-id='95e97e5e'/>
	</function-type>
	<function-type size-in-bits='64' id='250287b8'>
	<parameter type-id='b0c1ff8d'/>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='ee31ee44'/>
	<return type-id='95e97e5e'/>
	</function-type>
	<function-type size-in-bits='64' id='e7344862'>
	<parameter type-id='b0c1ff8d'/>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='d8bf0010'/>
	<return type-id='95e97e5e'/>
	</function-type>
	<function-type size-in-bits='64' id='32b6d968'>
	<parameter type-id='b0c1ff8d'/>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='149c6638'/>
	<return type-id='95e97e5e'/>
	</function-type>
	<function-type size-in-bits='64' id='5c975642'>
	<parameter type-id='b0c1ff8d'/>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='8f92235e'/>
	<return type-id='95e97e5e'/>
	</function-type>
	<function-type size-in-bits='64' id='0155b993'>
	<parameter type-id='b0c1ff8d'/>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='9c313c2d'/>
	<return type-id='95e97e5e'/>
	</function-type>
	<function-type size-in-bits='64' id='6e8b02cb'>
	<parameter type-id='b0c1ff8d'/>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='b96825af'/>
	<return type-id='95e97e5e'/>
	</function-type>
	<function-type size-in-bits='64' id='d434b7d7'>
	<parameter type-id='b0c1ff8d'/>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='45b65157'/>
	<parameter type-id='3502e3ff'/>
	<return type-id='95e97e5e'/>
	</function-type>
	<function-type size-in-bits='64' id='c645e10f'>
	<parameter type-id='b0c1ff8d'/>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='8a121f49'/>
	<parameter type-id='3502e3ff'/>
	<return type-id='95e97e5e'/>
	</function-type>
	<function-type size-in-bits='64' id='de41f295'>
	<parameter type-id='b0c1ff8d'/>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='90421557'/>
	<parameter type-id='3502e3ff'/>
	<return type-id='95e97e5e'/>
	</function-type>
	<function-type size-in-bits='64' id='b2fbf64a'>
	<parameter type-id='b0c1ff8d'/>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='5d6479ae'/>
	<parameter type-id='3502e3ff'/>
	<return type-id='95e97e5e'/>
	</function-type>
	<function-type size-in-bits='64' id='cc22d314'>
	<parameter type-id='b0c1ff8d'/>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='ae3e8ca6'/>
	<parameter type-id='3502e3ff'/>
	<return type-id='95e97e5e'/>
	</function-type>
	</abi-instr>
	- <abi-instr version='1.0' address-size='64' path='libnvpair_json.c' language='LANG_C89'>
	+ <abi-instr address-size='64' path='libnvpair_json.c' language='LANG_C99'>
	<array-type-def dimensions='1' type-id='a84c031d' size-in-bits='32' id='8e0573fd'>
	- <subrange length='4' type-id='4c87fef4' id='16fe7105'/>
	+ <subrange length='4' type-id='7359adad' id='16fe7105'/>
	</array-type-def>
	- <typedef-decl name='wchar_t' type-id='95e97e5e' id='928221d2'/>
	- <typedef-decl name='mbstate_t' type-id='55e5b2b5' id='3d7d8cbf'/>
	- <typedef-decl name='__mbstate_t' type-id='4acf628f' id='55e5b2b5'/>
	- <class-decl name='__anonymous_struct__' size-in-bits='64' is-struct='yes' is-anonymous='yes' naming-typedef-id='55e5b2b5' visibility='default' id='4acf628f'>
	+ <class-decl name='__mbstate_t' size-in-bits='64' is-struct='yes' naming-typedef-id='55e5b2b5' visibility='default' id='87447a2e'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='__count' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='32'>
	- <var-decl name='__value' type-id='ac5e8fac' visibility='default'/>
	+ <var-decl name='__value' type-id='ac5ab595' visibility='default'/>
	</data-member>
	</class-decl>
	- <union-decl name='__anonymous_union__' size-in-bits='32' is-anonymous='yes' visibility='default' id='ac5e8fac'>
	- <data-member access='private'>
	+ <union-decl name='__anonymous_union__' size-in-bits='32' is-anonymous='yes' visibility='default' id='ac5ab595'>
	+ <data-member access='public'>
	<var-decl name='__wch' type-id='f0981eeb' visibility='default'/>
	</data-member>
	- <data-member access='private'>
	+ <data-member access='public'>
	<var-decl name='__wchb' type-id='8e0573fd' visibility='default'/>
	</data-member>
	</union-decl>
	+ <typedef-decl name='__mbstate_t' type-id='87447a2e' id='55e5b2b5'/>
	+ <typedef-decl name='mbstate_t' type-id='55e5b2b5' id='3d7d8cbf'/>
	+ <typedef-decl name='wchar_t' type-id='95e97e5e' id='928221d2'/>
	<pointer-type-def type-id='3d7d8cbf' size-in-bits='64' id='a68021ce'/>
	+ <qualified-type-def type-id='a68021ce' restrict='yes' id='03aaab72'/>
	<pointer-type-def type-id='928221d2' size-in-bits='64' id='323d93c1'/>
	- <function-decl name='nvlist_print_json' mangled-name='nvlist_print_json' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_print_json'>
	- <parameter type-id='822cd80b' name='fp'/>
	- <parameter type-id='5ce45b60' name='nvl'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='__ctype_get_mb_cur_max' visibility='default' binding='global' size-in-bits='64'>
	- <return type-id='b59d7dce'/>
	- </function-decl>
	- <function-decl name='mbrtowc' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='323d93c1'/>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='b59d7dce'/>
	- <parameter type-id='a68021ce'/>
	- <return type-id='b59d7dce'/>
	- </function-decl>
	- <function-decl name='libspl_assertf' mangled-name='libspl_assertf' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libspl_assertf'>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='95e97e5e'/>
	- <parameter type-id='80f4b756'/>
	- <parameter is-variadic='yes'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	- <function-decl name='fnvpair_value_string' mangled-name='fnvpair_value_string' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvpair_value_string'>
	+ <qualified-type-def type-id='323d93c1' restrict='yes' id='f1358bc3'/>
	+ <function-decl name='fnvpair_value_boolean_value' mangled-name='fnvpair_value_boolean_value' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvpair_value_boolean_value'>
	<parameter type-id='3fa542f0'/>
	- <return type-id='26a90f95'/>
	+ <return type-id='c19b74c3'/>
	</function-decl>
	<function-decl name='fnvpair_value_byte' mangled-name='fnvpair_value_byte' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvpair_value_byte'>
	<parameter type-id='3fa542f0'/>
	<return type-id='d8bf0010'/>
	</function-decl>
	- <function-decl name='fnvpair_value_int16' mangled-name='fnvpair_value_int16' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvpair_value_int16'>
	+ <function-decl name='fnvpair_value_int8' mangled-name='fnvpair_value_int8' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvpair_value_int8'>
	<parameter type-id='3fa542f0'/>
	- <return type-id='23bd8cb5'/>
	+ <return type-id='ee31ee44'/>
	</function-decl>
	- <function-decl name='fnvpair_value_uint16' mangled-name='fnvpair_value_uint16' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvpair_value_uint16'>
	+ <function-decl name='fnvpair_value_int16' mangled-name='fnvpair_value_int16' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvpair_value_int16'>
	<parameter type-id='3fa542f0'/>
	- <return type-id='149c6638'/>
	+ <return type-id='23bd8cb5'/>
	</function-decl>
	<function-decl name='fnvpair_value_int32' mangled-name='fnvpair_value_int32' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvpair_value_int32'>
	<parameter type-id='3fa542f0'/>
	<return type-id='3ff5601b'/>
	</function-decl>
	- <function-decl name='fnvpair_value_uint32' mangled-name='fnvpair_value_uint32' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvpair_value_uint32'>
	- <parameter type-id='3fa542f0'/>
	- <return type-id='8f92235e'/>
	- </function-decl>
	<function-decl name='fnvpair_value_int64' mangled-name='fnvpair_value_int64' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvpair_value_int64'>
	<parameter type-id='3fa542f0'/>
	<return type-id='9da381c4'/>
	</function-decl>
	+ <function-decl name='fnvpair_value_uint8' mangled-name='fnvpair_value_uint8' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvpair_value_uint8'>
	+ <parameter type-id='3fa542f0'/>
	+ <return type-id='b96825af'/>
	+ </function-decl>
	+ <function-decl name='fnvpair_value_uint16' mangled-name='fnvpair_value_uint16' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvpair_value_uint16'>
	+ <parameter type-id='3fa542f0'/>
	+ <return type-id='149c6638'/>
	+ </function-decl>
	+ <function-decl name='fnvpair_value_uint32' mangled-name='fnvpair_value_uint32' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvpair_value_uint32'>
	+ <parameter type-id='3fa542f0'/>
	+ <return type-id='8f92235e'/>
	+ </function-decl>
	<function-decl name='fnvpair_value_uint64' mangled-name='fnvpair_value_uint64' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvpair_value_uint64'>
	<parameter type-id='3fa542f0'/>
	<return type-id='9c313c2d'/>
	</function-decl>
	+ <function-decl name='fnvpair_value_string' mangled-name='fnvpair_value_string' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvpair_value_string'>
	+ <parameter type-id='3fa542f0'/>
	+ <return type-id='26a90f95'/>
	+ </function-decl>
	<function-decl name='fnvpair_value_nvlist' mangled-name='fnvpair_value_nvlist' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvpair_value_nvlist'>
	<parameter type-id='3fa542f0'/>
	<return type-id='5ce45b60'/>
	</function-decl>
	- <function-decl name='fnvpair_value_boolean_value' mangled-name='fnvpair_value_boolean_value' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvpair_value_boolean_value'>
	- <parameter type-id='3fa542f0'/>
	- <return type-id='c19b74c3'/>
	+ <function-decl name='libspl_assertf' mangled-name='libspl_assertf' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libspl_assertf'>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='95e97e5e'/>
	+ <parameter type-id='80f4b756'/>
	+ <parameter is-variadic='yes'/>
	+ <return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='fnvpair_value_int8' mangled-name='fnvpair_value_int8' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvpair_value_int8'>
	- <parameter type-id='3fa542f0'/>
	- <return type-id='ee31ee44'/>
	+ <function-decl name='nvlist_print_json' mangled-name='nvlist_print_json' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='nvlist_print_json'>
	+ <parameter type-id='822cd80b' name='fp'/>
	+ <parameter type-id='5ce45b60' name='nvl'/>
	+ <return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='fnvpair_value_uint8' mangled-name='fnvpair_value_uint8' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fnvpair_value_uint8'>
	- <parameter type-id='3fa542f0'/>
	- <return type-id='b96825af'/>
	+ <function-decl name='__ctype_get_mb_cur_max' visibility='default' binding='global' size-in-bits='64'>
	+ <return type-id='b59d7dce'/>
	+ </function-decl>
	+ <function-decl name='mbrtowc' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='f1358bc3'/>
	+ <parameter type-id='9d26089a'/>
	+ <parameter type-id='b59d7dce'/>
	+ <parameter type-id='03aaab72'/>
	+ <return type-id='b59d7dce'/>
	</function-decl>
	</abi-instr>
	- <abi-instr version='1.0' address-size='64' path='nvpair_alloc_system.c' language='LANG_C89'>
	+ <abi-instr address-size='64' path='nvpair_alloc_system.c' language='LANG_C99'>
	<class-decl name='__va_list_tag' size-in-bits='192' is-struct='yes' visibility='default' id='d5027220'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='gp_offset' type-id='f0981eeb' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='32'>
	<var-decl name='fp_offset' type-id='f0981eeb' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='overflow_arg_area' type-id='eaa32e2f' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='reg_save_area' type-id='eaa32e2f' visibility='default'/>
	</data-member>
	</class-decl>
	+ <typedef-decl name='nv_alloc_ops_t' type-id='8f6cc4f4' id='03e8ffd6'/>
	<class-decl name='nv_alloc' size-in-bits='128' is-struct='yes' visibility='default' id='98213087'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='nva_ops' type-id='ee1d4944' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='nva_arg' type-id='eaa32e2f' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='nv_alloc_ops_t' type-id='8f6cc4f4' id='03e8ffd6'/>
	+ <typedef-decl name='nv_alloc_t' type-id='98213087' id='cca08635'/>
	<class-decl name='nv_alloc_ops' size-in-bits='320' is-struct='yes' visibility='default' id='8f6cc4f4'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='nv_ao_init' type-id='76da8447' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='nv_ao_fini' type-id='fe356f6f' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='nv_ao_alloc' type-id='9ff7f508' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	<var-decl name='nv_ao_free' type-id='520da3f4' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='256'>
	<var-decl name='nv_ao_reset' type-id='fe356f6f' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='nv_alloc_t' type-id='98213087' id='cca08635'/>
	<pointer-type-def type-id='d5027220' size-in-bits='64' id='b7f2d5e6'/>
	<qualified-type-def type-id='03e8ffd6' const='yes' id='aca16c06'/>
	<pointer-type-def type-id='aca16c06' size-in-bits='64' id='ee1d4944'/>
	<pointer-type-def type-id='e9ff7293' size-in-bits='64' id='76da8447'/>
	<pointer-type-def type-id='cca08635' size-in-bits='64' id='11871392'/>
	<pointer-type-def type-id='51a21b4b' size-in-bits='64' id='fe356f6f'/>
	<pointer-type-def type-id='1169c032' size-in-bits='64' id='520da3f4'/>
	<pointer-type-def type-id='9fff962e' size-in-bits='64' id='9ff7f508'/>
	<var-decl name='nv_alloc_nosleep' type-id='11871392' mangled-name='nv_alloc_nosleep' visibility='default' elf-symbol-id='nv_alloc_nosleep'/>
	<var-decl name='nv_alloc_sleep_def' type-id='cca08635' mangled-name='nv_alloc_sleep_def' visibility='default' elf-symbol-id='nv_alloc_sleep_def'/>
	<var-decl name='nv_alloc_nosleep_def' type-id='cca08635' mangled-name='nv_alloc_nosleep_def' visibility='default' elf-symbol-id='nv_alloc_nosleep_def'/>
	<var-decl name='nv_alloc_sleep' type-id='11871392' mangled-name='nv_alloc_sleep' visibility='default' elf-symbol-id='nv_alloc_sleep'/>
	<function-type size-in-bits='64' id='e9ff7293'>
	<parameter type-id='11871392'/>
	<parameter type-id='b7f2d5e6'/>
	<return type-id='95e97e5e'/>
	</function-type>
	+ <function-type size-in-bits='64' id='51a21b4b'>
	+ <parameter type-id='11871392'/>
	+ <return type-id='48b5725f'/>
	+ </function-type>
	<function-type size-in-bits='64' id='1169c032'>
	<parameter type-id='11871392'/>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='b59d7dce'/>
	<return type-id='48b5725f'/>
	</function-type>
	<function-type size-in-bits='64' id='9fff962e'>
	<parameter type-id='11871392'/>
	<parameter type-id='b59d7dce'/>
	<return type-id='eaa32e2f'/>
	</function-type>
	</abi-instr>
	- <abi-instr version='1.0' address-size='64' path='assert.c' language='LANG_C89'>
	+ <abi-instr address-size='64' path='assert.c' language='LANG_C99'>
	<var-decl name='aok' type-id='95e97e5e' mangled-name='aok' visibility='default' elf-symbol-id='aok'/>
	<function-decl name='vfprintf' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='822cd80b'/>
	- <parameter type-id='80f4b756'/>
	+ <parameter type-id='e75a27e9'/>
	+ <parameter type-id='9d26089a'/>
	<parameter type-id='b7f2d5e6'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='abort' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='48b5725f'/>
	</function-decl>
	</abi-instr>
	</abi-corpus>
	diff --git a/sys/contrib/openzfs/lib/libspl/include/os/freebsd/sys/zfs_context_os.h b/sys/contrib/openzfs/lib/libspl/include/os/freebsd/sys/zfs_context_os.h
	index f5a136d22125..b9bf487c2aef 100644
	--- a/sys/contrib/openzfs/lib/libspl/include/os/freebsd/sys/zfs_context_os.h
	+++ b/sys/contrib/openzfs/lib/libspl/include/os/freebsd/sys/zfs_context_os.h
	@@ -1,34 +1,35 @@
	/*
	* 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 ZFS_CONTEXT_OS_H_
	#define ZFS_CONTEXT_OS_H_

	+#define HAVE_LARGE_STACKS 1
	#define ZFS_EXPORTS_PATH "/etc/zfs/exports"

	#endif
	diff --git a/sys/contrib/openzfs/lib/libspl/include/os/linux/sys/zfs_context_os.h b/sys/contrib/openzfs/lib/libspl/include/os/linux/sys/zfs_context_os.h
	index 008e57df4eae..81ced5207749 100644
	--- a/sys/contrib/openzfs/lib/libspl/include/os/linux/sys/zfs_context_os.h
	+++ b/sys/contrib/openzfs/lib/libspl/include/os/linux/sys/zfs_context_os.h
	@@ -1,25 +1,28 @@
	/*
	* 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
	*/

	#ifndef ZFS_CONTEXT_OS_H
	#define ZFS_CONTEXT_OS_H
	+
	+#define HAVE_LARGE_STACKS 1
	+
	#endif
	diff --git a/sys/contrib/openzfs/lib/libspl/include/sys/feature_tests.h b/sys/contrib/openzfs/lib/libspl/include/sys/feature_tests.h
	index 1a68b75f0cdc..c9564b2c3269 100644
	--- a/sys/contrib/openzfs/lib/libspl/include/sys/feature_tests.h
	+++ b/sys/contrib/openzfs/lib/libspl/include/sys/feature_tests.h
	@@ -1,32 +1,41 @@
	/*
	* 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 2006 Sun Microsystems, Inc. All rights reserved.
	* Use is subject to license terms.
	*/

	#ifndef _SYS_FEATURE_TESTS_H
	#define _SYS_FEATURE_TESTS_H

	-#define __NORETURN __attribute__((__noreturn__))
	+#define ____cacheline_aligned
	+#define __NORETURN __attribute__((__noreturn__))
	+
	+#if !defined(fallthrough) && !defined(_LIBCPP_VERSION)
	+#if defined(HAVE_IMPLICIT_FALLTHROUGH)
	+#define fallthrough __attribute__((__fallthrough__))
	+#else
	+#define fallthrough ((void)0)
	+#endif
	+#endif

	#endif
	diff --git a/sys/contrib/openzfs/lib/libuutil/libuutil.abi b/sys/contrib/openzfs/lib/libuutil/libuutil.abi
	index 80af147a1ea1..21418ec1d4a0 100644
	--- a/sys/contrib/openzfs/lib/libuutil/libuutil.abi
	+++ b/sys/contrib/openzfs/lib/libuutil/libuutil.abi
	@@ -1,2731 +1,2276 @@
	-<abi-corpus architecture='elf-amd-x86_64' soname='libuutil.so.3'>
	+<abi-corpus version='2.0' architecture='elf-amd-x86_64' soname='libuutil.so.3'>
	<elf-needed>
	- <dependency name='libpthread.so.0'/>
	<dependency name='libc.so.6'/>
	<dependency name='ld-linux-x86-64.so.2'/>
	</elf-needed>
	<elf-function-symbols>
	- <elf-symbol name='_fini' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	- <elf-symbol name='_init' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='_sol_getmntent' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_add_16' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_add_16_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_add_32' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_add_32_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_add_64' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_add_64_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_add_8' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_add_8_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_add_char' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_add_char_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_add_int' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_add_int_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_add_long' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_add_long_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_add_ptr' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_add_ptr_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_add_short' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_add_short_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_and_16' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_and_16_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_and_32' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_and_32_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_and_64' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_and_64_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_and_8' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_and_8_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_and_uchar' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_and_uchar_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_and_uint' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_and_uint_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_and_ulong' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_and_ulong_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_and_ushort' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_and_ushort_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_cas_16' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_cas_32' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_cas_64' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_cas_8' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_cas_ptr' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_cas_uchar' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_cas_uint' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_cas_ulong' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_cas_ushort' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_clear_long_excl' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_dec_16' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_dec_16_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_dec_32' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_dec_32_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_dec_64' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_dec_64_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_dec_8' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_dec_8_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_dec_uchar' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_dec_uchar_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_dec_uint' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_dec_uint_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_dec_ulong' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_dec_ulong_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_dec_ushort' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_dec_ushort_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_inc_16' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_inc_16_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_inc_32' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_inc_32_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_inc_64' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_inc_64_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_inc_8' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_inc_8_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_inc_uchar' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_inc_uchar_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_inc_uint' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_inc_uint_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_inc_ulong' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_inc_ulong_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_inc_ushort' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_inc_ushort_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_or_16' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_or_16_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_or_32' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_or_32_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_or_64' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_or_64_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_or_8' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_or_8_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_or_uchar' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_or_uchar_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_or_uint' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_or_uint_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_or_ulong' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_or_ulong_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_or_ushort' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_or_ushort_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_set_long_excl' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_sub_16' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_sub_16_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_sub_32' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_sub_32_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_sub_64' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_sub_64_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_sub_8' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_sub_8_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_sub_char' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_sub_char_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_sub_int' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_sub_int_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_sub_long' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_sub_long_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_sub_ptr' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_sub_ptr_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_sub_short' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_sub_short_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_swap_16' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_swap_32' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_swap_64' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_swap_8' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_swap_ptr' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_swap_uchar' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_swap_uint' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_swap_ulong' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_swap_ushort' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='avl_add' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='avl_create' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='avl_destroy' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='avl_destroy_nodes' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='avl_find' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='avl_first' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='avl_insert' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='avl_insert_here' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='avl_is_empty' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='avl_last' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='avl_nearest' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='avl_numnodes' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='avl_remove' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='avl_swap' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='avl_update' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='avl_update_gt' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='avl_update_lt' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='avl_walk' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='get_system_hostid' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='getexecname' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='getextmntent' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='getmntany' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='getzoneid' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='libspl_assertf' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='list_create' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='list_destroy' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='list_head' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='list_insert_after' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='list_insert_before' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='list_insert_head' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='list_insert_tail' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='list_is_empty' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='list_link_active' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='list_link_init' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='list_link_replace' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='list_move_tail' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='list_next' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='list_prev' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='list_remove' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='list_remove_head' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='list_remove_tail' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='list_tail' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='membar_consumer' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='membar_enter' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='membar_exit' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='membar_producer' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='mkdirp' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='print_timestamp' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='spl_pagesize' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='strlcat' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='strlcpy' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_alt_exit' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_avl_create' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_avl_destroy' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_avl_find' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_avl_first' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_avl_insert' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_avl_last' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_avl_lockup' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_avl_nearest_next' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_avl_nearest_prev' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_avl_next' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_avl_node_fini' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_avl_node_init' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_avl_numnodes' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_avl_pool_create' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_avl_pool_destroy' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_avl_prev' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_avl_release' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_avl_remove' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_avl_teardown' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_avl_walk' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_avl_walk_end' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_avl_walk_next' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_avl_walk_start' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_check_name' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_die' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_dprintf' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_dprintf_create' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_dprintf_destroy' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_dprintf_getname' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_dump' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_error' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_exit_fatal' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_exit_ok' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_exit_usage' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_free' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_getpname' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_list_create' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_list_destroy' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_list_find' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_list_first' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_list_insert' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_list_insert_after' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_list_insert_before' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_list_last' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_list_lockup' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_list_nearest_next' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_list_nearest_prev' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_list_next' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_list_node_fini' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_list_node_init' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_list_numnodes' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_list_pool_create' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_list_pool_destroy' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_list_prev' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_list_release' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_list_remove' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_list_teardown' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_list_walk' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_list_walk_end' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_list_walk_next' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_list_walk_start' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_memdup' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_msprintf' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_open_tmp' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_panic' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_set_error' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_setpname' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_strbw' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_strcaseeq' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_strdup' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_streq' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_strerror' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_strndup' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_vdie' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_vwarn' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_vxdie' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_warn' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_xdie' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_zalloc' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	</elf-function-symbols>
	<elf-variable-symbols>
	<elf-symbol name='aok' size='4' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='buf' size='4110' type='tls-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='pagesize' size='8' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_exit_fatal_value' size='4' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_exit_ok_value' size='4' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='uu_exit_usage_value' size='4' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	</elf-variable-symbols>
	- <abi-instr version='1.0' address-size='64' path='../../module/avl/avl.c' language='LANG_C89'>
	+ <abi-instr address-size='64' path='../../module/avl/avl.c' language='LANG_C99'>
	+ <function-decl name='libspl_assertf' mangled-name='libspl_assertf' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libspl_assertf'>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='95e97e5e'/>
	+ <parameter type-id='80f4b756'/>
	+ <parameter is-variadic='yes'/>
	+ <return type-id='48b5725f'/>
	+ </function-decl>
	<function-decl name='avl_insert_here' mangled-name='avl_insert_here' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='avl_insert_here'>
	<parameter type-id='a3681dea' name='tree'/>
	<parameter type-id='eaa32e2f' name='new_data'/>
	<parameter type-id='eaa32e2f' name='here'/>
	<parameter type-id='95e97e5e' name='direction'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='avl_add' mangled-name='avl_add' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='avl_add'>
	<parameter type-id='a3681dea' name='tree'/>
	<parameter type-id='eaa32e2f' name='new_node'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='avl_update_lt' mangled-name='avl_update_lt' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='avl_update_lt'>
	<parameter type-id='a3681dea' name='t'/>
	<parameter type-id='eaa32e2f' name='obj'/>
	<return type-id='c19b74c3'/>
	</function-decl>
	<function-decl name='avl_update_gt' mangled-name='avl_update_gt' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='avl_update_gt'>
	<parameter type-id='a3681dea' name='t'/>
	<parameter type-id='eaa32e2f' name='obj'/>
	<return type-id='c19b74c3'/>
	</function-decl>
	<function-decl name='avl_update' mangled-name='avl_update' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='avl_update'>
	<parameter type-id='a3681dea' name='t'/>
	<parameter type-id='eaa32e2f' name='obj'/>
	<return type-id='c19b74c3'/>
	</function-decl>
	<function-decl name='avl_swap' mangled-name='avl_swap' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='avl_swap'>
	<parameter type-id='a3681dea' name='tree1'/>
	<parameter type-id='a3681dea' name='tree2'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='avl_is_empty' mangled-name='avl_is_empty' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='avl_is_empty'>
	<parameter type-id='a3681dea' name='tree'/>
	<return type-id='c19b74c3'/>
	</function-decl>
	- <function-decl name='libspl_assertf' mangled-name='libspl_assertf' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libspl_assertf'>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='95e97e5e'/>
	- <parameter type-id='80f4b756'/>
	- <parameter is-variadic='yes'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	- <pointer-type-def type-id='f20fbd51' size-in-bits='64' id='a3681dea'/>
	- <pointer-type-def type-id='9b45d938' size-in-bits='64' id='80f4b756'/>
	- <type-decl name='int' size-in-bits='32' id='95e97e5e'/>
	- <typedef-decl name='boolean_t' type-id='08f5ca17' id='c19b74c3'/>
	- <type-decl name='void' id='48b5725f'/>
	- <pointer-type-def type-id='48b5725f' size-in-bits='64' id='eaa32e2f'/>
	- <qualified-type-def type-id='a84c031d' const='yes' id='9b45d938'/>
	- <enum-decl name='__anonymous_enum__' is-anonymous='yes' id='08f5ca17'>
	- <underlying-type type-id='9cac1fee'/>
	- <enumerator name='B_FALSE' value='0'/>
	- <enumerator name='B_TRUE' value='1'/>
	- </enum-decl>
	- <typedef-decl name='avl_tree_t' type-id='b351119f' id='f20fbd51'/>
	- <type-decl name='char' size-in-bits='8' id='a84c031d'/>
	- <class-decl name='avl_tree' size-in-bits='320' is-struct='yes' visibility='default' id='b351119f'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='avl_root' type-id='bf311473' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='avl_compar' type-id='585e1de9' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='avl_offset' type-id='b59d7dce' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='192'>
	- <var-decl name='avl_numnodes' type-id='ee1f298e' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='256'>
	- <var-decl name='avl_size' type-id='b59d7dce' visibility='default'/>
	- </data-member>
	- </class-decl>
	- <pointer-type-def type-id='428b67b3' size-in-bits='64' id='bf311473'/>
	- <pointer-type-def type-id='96ee24a5' size-in-bits='64' id='585e1de9'/>
	- <typedef-decl name='size_t' type-id='7359adad' id='b59d7dce'/>
	- <typedef-decl name='ulong_t' type-id='7359adad' id='ee1f298e'/>
	- <class-decl name='avl_node' size-in-bits='192' is-struct='yes' visibility='default' id='428b67b3'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='avl_child' type-id='f0f65199' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='avl_pcb' type-id='e475ab95' visibility='default'/>
	- </data-member>
	- </class-decl>
	- <type-decl name='unsigned long int' size-in-bits='64' id='7359adad'/>
	- <array-type-def dimensions='1' type-id='bf311473' size-in-bits='128' id='f0f65199'>
	- <subrange length='2' type-id='4c87fef4' id='52efc4ef'/>
	- </array-type-def>
	- <typedef-decl name='uintptr_t' type-id='7359adad' id='e475ab95'/>
	- <type-decl name='sizetype' size-in-bits='64' id='4c87fef4'/>
	</abi-instr>
	- <abi-instr version='1.0' address-size='64' path='assert.c' language='LANG_C89'>
	+ <abi-instr address-size='64' path='assert.c' language='LANG_C99'>
	<var-decl name='aok' type-id='95e97e5e' mangled-name='aok' visibility='default' elf-symbol-id='aok'/>
	</abi-instr>
	- <abi-instr version='1.0' address-size='64' path='atomic.c' language='LANG_C89'>
	- <typedef-decl name='uchar_t' type-id='002ac4a6' id='d8bf0010'/>
	- <typedef-decl name='uint16_t' type-id='8efea9e5' id='149c6638'/>
	- <typedef-decl name='ushort_t' type-id='8efea9e5' id='d908a348'/>
	- <typedef-decl name='uint64_t' type-id='7359adad' id='9c313c2d'/>
	- <typedef-decl name='int16_t' type-id='a2185560' id='23bd8cb5'/>
	- <typedef-decl name='int32_t' type-id='95e97e5e' id='3ff5601b'/>
	- <typedef-decl name='int64_t' type-id='bd54fe1a' id='9da381c4'/>
	- <typedef-decl name='ssize_t' type-id='41060289' id='79a0948f'/>
	+ <abi-instr address-size='64' path='atomic.c' language='LANG_C99'>
	+ <typedef-decl name='int16_t' type-id='03896e23' id='23bd8cb5'/>
	+ <typedef-decl name='int32_t' type-id='33f57a65' id='3ff5601b'/>
	+ <typedef-decl name='uint16_t' type-id='253c2d2a' id='149c6638'/>
	+ <typedef-decl name='__int16_t' type-id='a2185560' id='03896e23'/>
	+ <typedef-decl name='__uint16_t' type-id='8efea9e5' id='253c2d2a'/>
	+ <typedef-decl name='__int32_t' type-id='95e97e5e' id='33f57a65'/>
	<typedef-decl name='__ssize_t' type-id='bd54fe1a' id='41060289'/>
	- <qualified-type-def type-id='d8bf0010' volatile='yes' id='b867ca41'/>
	- <pointer-type-def type-id='b867ca41' size-in-bits='64' id='b663a671'/>
	+ <typedef-decl name='ssize_t' type-id='41060289' id='79a0948f'/>
	<qualified-type-def type-id='149c6638' volatile='yes' id='5120c5f7'/>
	<pointer-type-def type-id='5120c5f7' size-in-bits='64' id='93977ae7'/>
	<qualified-type-def type-id='8f92235e' volatile='yes' id='430e0681'/>
	<pointer-type-def type-id='430e0681' size-in-bits='64' id='3a147f31'/>
	- <qualified-type-def type-id='9c313c2d' volatile='yes' id='4f4abd5e'/>
	- <pointer-type-def type-id='4f4abd5e' size-in-bits='64' id='46a83d9c'/>
	<qualified-type-def type-id='b96825af' volatile='yes' id='84ff7d66'/>
	<pointer-type-def type-id='84ff7d66' size-in-bits='64' id='aa323ea4'/>
	- <qualified-type-def type-id='3502e3ff' volatile='yes' id='d0290e74'/>
	- <pointer-type-def type-id='d0290e74' size-in-bits='64' id='0ea19dfa'/>
	<qualified-type-def type-id='ee1f298e' volatile='yes' id='6f7e09cb'/>
	<pointer-type-def type-id='6f7e09cb' size-in-bits='64' id='64698d33'/>
	- <qualified-type-def type-id='d908a348' volatile='yes' id='65d4726b'/>
	- <pointer-type-def type-id='65d4726b' size-in-bits='64' id='8e6fdc53'/>
	<qualified-type-def type-id='48b5725f' volatile='yes' id='b0b3cbf9'/>
	<pointer-type-def type-id='b0b3cbf9' size-in-bits='64' id='fe09dd29'/>
	<function-decl name='atomic_inc_8' mangled-name='atomic_inc_8' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_inc_8'>
	<parameter type-id='aa323ea4' name='target'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='atomic_inc_uchar' mangled-name='atomic_inc_uchar' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_inc_uchar'>
	- <parameter type-id='b663a671' name='target'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	<function-decl name='atomic_inc_16' mangled-name='atomic_inc_16' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_inc_16'>
	<parameter type-id='93977ae7' name='target'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='atomic_inc_ushort' mangled-name='atomic_inc_ushort' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_inc_ushort'>
	- <parameter type-id='8e6fdc53' name='target'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	<function-decl name='atomic_inc_32' mangled-name='atomic_inc_32' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_inc_32'>
	<parameter type-id='3a147f31' name='target'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='atomic_inc_uint' mangled-name='atomic_inc_uint' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_inc_uint'>
	- <parameter type-id='0ea19dfa' name='target'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	<function-decl name='atomic_inc_ulong' mangled-name='atomic_inc_ulong' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_inc_ulong'>
	<parameter type-id='64698d33' name='target'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='atomic_inc_64' mangled-name='atomic_inc_64' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_inc_64'>
	- <parameter type-id='46a83d9c' name='target'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	<function-decl name='atomic_dec_8' mangled-name='atomic_dec_8' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_dec_8'>
	<parameter type-id='aa323ea4' name='target'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='atomic_dec_uchar' mangled-name='atomic_dec_uchar' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_dec_uchar'>
	- <parameter type-id='b663a671' name='target'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	<function-decl name='atomic_dec_16' mangled-name='atomic_dec_16' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_dec_16'>
	<parameter type-id='93977ae7' name='target'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='atomic_dec_ushort' mangled-name='atomic_dec_ushort' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_dec_ushort'>
	- <parameter type-id='8e6fdc53' name='target'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	<function-decl name='atomic_dec_32' mangled-name='atomic_dec_32' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_dec_32'>
	<parameter type-id='3a147f31' name='target'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='atomic_dec_uint' mangled-name='atomic_dec_uint' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_dec_uint'>
	- <parameter type-id='0ea19dfa' name='target'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	<function-decl name='atomic_dec_ulong' mangled-name='atomic_dec_ulong' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_dec_ulong'>
	<parameter type-id='64698d33' name='target'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='atomic_dec_64' mangled-name='atomic_dec_64' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_dec_64'>
	- <parameter type-id='46a83d9c' name='target'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	<function-decl name='atomic_add_8' mangled-name='atomic_add_8' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_add_8'>
	<parameter type-id='aa323ea4' name='target'/>
	<parameter type-id='ee31ee44' name='bits'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='atomic_add_char' mangled-name='atomic_add_char' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_add_char'>
	- <parameter type-id='b663a671' name='target'/>
	- <parameter type-id='28577a57' name='bits'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	<function-decl name='atomic_add_16' mangled-name='atomic_add_16' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_add_16'>
	<parameter type-id='93977ae7' name='target'/>
	<parameter type-id='23bd8cb5' name='bits'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='atomic_add_short' mangled-name='atomic_add_short' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_add_short'>
	- <parameter type-id='8e6fdc53' name='target'/>
	- <parameter type-id='a2185560' name='bits'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	<function-decl name='atomic_add_32' mangled-name='atomic_add_32' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_add_32'>
	<parameter type-id='3a147f31' name='target'/>
	<parameter type-id='3ff5601b' name='bits'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='atomic_add_int' mangled-name='atomic_add_int' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_add_int'>
	- <parameter type-id='0ea19dfa' name='target'/>
	- <parameter type-id='95e97e5e' name='bits'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	- <function-decl name='atomic_add_long' mangled-name='atomic_add_long' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_add_long'>
	- <parameter type-id='64698d33' name='target'/>
	- <parameter type-id='bd54fe1a' name='bits'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	- <function-decl name='atomic_add_64' mangled-name='atomic_add_64' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_add_64'>
	- <parameter type-id='46a83d9c' name='target'/>
	- <parameter type-id='9da381c4' name='bits'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	<function-decl name='atomic_add_ptr' mangled-name='atomic_add_ptr' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_add_ptr'>
	<parameter type-id='fe09dd29' name='target'/>
	<parameter type-id='79a0948f' name='bits'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='atomic_sub_8' mangled-name='atomic_sub_8' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_sub_8'>
	<parameter type-id='aa323ea4' name='target'/>
	<parameter type-id='ee31ee44' name='bits'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='atomic_sub_char' mangled-name='atomic_sub_char' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_sub_char'>
	- <parameter type-id='b663a671' name='target'/>
	- <parameter type-id='28577a57' name='bits'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	<function-decl name='atomic_sub_16' mangled-name='atomic_sub_16' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_sub_16'>
	<parameter type-id='93977ae7' name='target'/>
	<parameter type-id='23bd8cb5' name='bits'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='atomic_sub_short' mangled-name='atomic_sub_short' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_sub_short'>
	- <parameter type-id='8e6fdc53' name='target'/>
	- <parameter type-id='a2185560' name='bits'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	<function-decl name='atomic_sub_32' mangled-name='atomic_sub_32' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_sub_32'>
	<parameter type-id='3a147f31' name='target'/>
	<parameter type-id='3ff5601b' name='bits'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='atomic_sub_int' mangled-name='atomic_sub_int' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_sub_int'>
	- <parameter type-id='0ea19dfa' name='target'/>
	- <parameter type-id='95e97e5e' name='bits'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	- <function-decl name='atomic_sub_long' mangled-name='atomic_sub_long' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_sub_long'>
	- <parameter type-id='64698d33' name='target'/>
	- <parameter type-id='bd54fe1a' name='bits'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	- <function-decl name='atomic_sub_64' mangled-name='atomic_sub_64' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_sub_64'>
	- <parameter type-id='46a83d9c' name='target'/>
	- <parameter type-id='9da381c4' name='bits'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	<function-decl name='atomic_sub_ptr' mangled-name='atomic_sub_ptr' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_sub_ptr'>
	<parameter type-id='fe09dd29' name='target'/>
	<parameter type-id='79a0948f' name='bits'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='atomic_or_8' mangled-name='atomic_or_8' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_or_8'>
	<parameter type-id='aa323ea4' name='target'/>
	<parameter type-id='b96825af' name='bits'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='atomic_or_uchar' mangled-name='atomic_or_uchar' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_or_uchar'>
	- <parameter type-id='b663a671' name='target'/>
	- <parameter type-id='d8bf0010' name='bits'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	<function-decl name='atomic_or_16' mangled-name='atomic_or_16' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_or_16'>
	<parameter type-id='93977ae7' name='target'/>
	<parameter type-id='149c6638' name='bits'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='atomic_or_ushort' mangled-name='atomic_or_ushort' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_or_ushort'>
	- <parameter type-id='8e6fdc53' name='target'/>
	- <parameter type-id='d908a348' name='bits'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	<function-decl name='atomic_or_32' mangled-name='atomic_or_32' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_or_32'>
	<parameter type-id='3a147f31' name='target'/>
	<parameter type-id='8f92235e' name='bits'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='atomic_or_uint' mangled-name='atomic_or_uint' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_or_uint'>
	- <parameter type-id='0ea19dfa' name='target'/>
	- <parameter type-id='3502e3ff' name='bits'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	<function-decl name='atomic_or_ulong' mangled-name='atomic_or_ulong' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_or_ulong'>
	<parameter type-id='64698d33' name='target'/>
	<parameter type-id='ee1f298e' name='bits'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='atomic_or_64' mangled-name='atomic_or_64' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_or_64'>
	- <parameter type-id='46a83d9c' name='target'/>
	- <parameter type-id='9c313c2d' name='bits'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	<function-decl name='atomic_and_8' mangled-name='atomic_and_8' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_and_8'>
	<parameter type-id='aa323ea4' name='target'/>
	<parameter type-id='b96825af' name='bits'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='atomic_and_uchar' mangled-name='atomic_and_uchar' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_and_uchar'>
	- <parameter type-id='b663a671' name='target'/>
	- <parameter type-id='d8bf0010' name='bits'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	<function-decl name='atomic_and_16' mangled-name='atomic_and_16' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_and_16'>
	<parameter type-id='93977ae7' name='target'/>
	<parameter type-id='149c6638' name='bits'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='atomic_and_ushort' mangled-name='atomic_and_ushort' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_and_ushort'>
	- <parameter type-id='8e6fdc53' name='target'/>
	- <parameter type-id='d908a348' name='bits'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	<function-decl name='atomic_and_32' mangled-name='atomic_and_32' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_and_32'>
	<parameter type-id='3a147f31' name='target'/>
	<parameter type-id='8f92235e' name='bits'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='atomic_and_uint' mangled-name='atomic_and_uint' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_and_uint'>
	- <parameter type-id='0ea19dfa' name='target'/>
	- <parameter type-id='3502e3ff' name='bits'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	<function-decl name='atomic_and_ulong' mangled-name='atomic_and_ulong' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_and_ulong'>
	<parameter type-id='64698d33' name='target'/>
	<parameter type-id='ee1f298e' name='bits'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='atomic_and_64' mangled-name='atomic_and_64' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_and_64'>
	- <parameter type-id='46a83d9c' name='target'/>
	- <parameter type-id='9c313c2d' name='bits'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	<function-decl name='atomic_inc_8_nv' mangled-name='atomic_inc_8_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_inc_8_nv'>
	<parameter type-id='aa323ea4' name='target'/>
	<return type-id='b96825af'/>
	</function-decl>
	- <function-decl name='atomic_inc_uchar_nv' mangled-name='atomic_inc_uchar_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_inc_uchar_nv'>
	- <parameter type-id='b663a671' name='target'/>
	- <return type-id='d8bf0010'/>
	- </function-decl>
	<function-decl name='atomic_inc_16_nv' mangled-name='atomic_inc_16_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_inc_16_nv'>
	<parameter type-id='93977ae7' name='target'/>
	<return type-id='149c6638'/>
	</function-decl>
	- <function-decl name='atomic_inc_ushort_nv' mangled-name='atomic_inc_ushort_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_inc_ushort_nv'>
	- <parameter type-id='8e6fdc53' name='target'/>
	- <return type-id='d908a348'/>
	- </function-decl>
	<function-decl name='atomic_inc_32_nv' mangled-name='atomic_inc_32_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_inc_32_nv'>
	<parameter type-id='3a147f31' name='target'/>
	<return type-id='8f92235e'/>
	</function-decl>
	- <function-decl name='atomic_inc_uint_nv' mangled-name='atomic_inc_uint_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_inc_uint_nv'>
	- <parameter type-id='0ea19dfa' name='target'/>
	- <return type-id='3502e3ff'/>
	- </function-decl>
	<function-decl name='atomic_inc_ulong_nv' mangled-name='atomic_inc_ulong_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_inc_ulong_nv'>
	<parameter type-id='64698d33' name='target'/>
	<return type-id='ee1f298e'/>
	</function-decl>
	- <function-decl name='atomic_inc_64_nv' mangled-name='atomic_inc_64_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_inc_64_nv'>
	- <parameter type-id='46a83d9c' name='target'/>
	- <return type-id='9c313c2d'/>
	- </function-decl>
	<function-decl name='atomic_dec_8_nv' mangled-name='atomic_dec_8_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_dec_8_nv'>
	<parameter type-id='aa323ea4' name='target'/>
	<return type-id='b96825af'/>
	</function-decl>
	- <function-decl name='atomic_dec_uchar_nv' mangled-name='atomic_dec_uchar_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_dec_uchar_nv'>
	- <parameter type-id='b663a671' name='target'/>
	- <return type-id='d8bf0010'/>
	- </function-decl>
	<function-decl name='atomic_dec_16_nv' mangled-name='atomic_dec_16_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_dec_16_nv'>
	<parameter type-id='93977ae7' name='target'/>
	<return type-id='149c6638'/>
	</function-decl>
	- <function-decl name='atomic_dec_ushort_nv' mangled-name='atomic_dec_ushort_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_dec_ushort_nv'>
	- <parameter type-id='8e6fdc53' name='target'/>
	- <return type-id='d908a348'/>
	- </function-decl>
	<function-decl name='atomic_dec_32_nv' mangled-name='atomic_dec_32_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_dec_32_nv'>
	<parameter type-id='3a147f31' name='target'/>
	<return type-id='8f92235e'/>
	</function-decl>
	- <function-decl name='atomic_dec_uint_nv' mangled-name='atomic_dec_uint_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_dec_uint_nv'>
	- <parameter type-id='0ea19dfa' name='target'/>
	- <return type-id='3502e3ff'/>
	- </function-decl>
	<function-decl name='atomic_dec_ulong_nv' mangled-name='atomic_dec_ulong_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_dec_ulong_nv'>
	<parameter type-id='64698d33' name='target'/>
	<return type-id='ee1f298e'/>
	</function-decl>
	- <function-decl name='atomic_dec_64_nv' mangled-name='atomic_dec_64_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_dec_64_nv'>
	- <parameter type-id='46a83d9c' name='target'/>
	- <return type-id='9c313c2d'/>
	- </function-decl>
	<function-decl name='atomic_add_8_nv' mangled-name='atomic_add_8_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_add_8_nv'>
	<parameter type-id='aa323ea4' name='target'/>
	<parameter type-id='ee31ee44' name='bits'/>
	<return type-id='b96825af'/>
	</function-decl>
	- <function-decl name='atomic_add_char_nv' mangled-name='atomic_add_char_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_add_char_nv'>
	- <parameter type-id='b663a671' name='target'/>
	- <parameter type-id='28577a57' name='bits'/>
	- <return type-id='d8bf0010'/>
	- </function-decl>
	<function-decl name='atomic_add_16_nv' mangled-name='atomic_add_16_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_add_16_nv'>
	<parameter type-id='93977ae7' name='target'/>
	<parameter type-id='23bd8cb5' name='bits'/>
	<return type-id='149c6638'/>
	</function-decl>
	- <function-decl name='atomic_add_short_nv' mangled-name='atomic_add_short_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_add_short_nv'>
	- <parameter type-id='8e6fdc53' name='target'/>
	- <parameter type-id='a2185560' name='bits'/>
	- <return type-id='d908a348'/>
	- </function-decl>
	<function-decl name='atomic_add_32_nv' mangled-name='atomic_add_32_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_add_32_nv'>
	<parameter type-id='3a147f31' name='target'/>
	<parameter type-id='3ff5601b' name='bits'/>
	<return type-id='8f92235e'/>
	</function-decl>
	- <function-decl name='atomic_add_int_nv' mangled-name='atomic_add_int_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_add_int_nv'>
	- <parameter type-id='0ea19dfa' name='target'/>
	- <parameter type-id='95e97e5e' name='bits'/>
	- <return type-id='3502e3ff'/>
	- </function-decl>
	<function-decl name='atomic_add_long_nv' mangled-name='atomic_add_long_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_add_long_nv'>
	<parameter type-id='64698d33' name='target'/>
	<parameter type-id='bd54fe1a' name='bits'/>
	<return type-id='ee1f298e'/>
	</function-decl>
	- <function-decl name='atomic_add_64_nv' mangled-name='atomic_add_64_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_add_64_nv'>
	- <parameter type-id='46a83d9c' name='target'/>
	- <parameter type-id='9da381c4' name='bits'/>
	- <return type-id='9c313c2d'/>
	- </function-decl>
	<function-decl name='atomic_add_ptr_nv' mangled-name='atomic_add_ptr_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_add_ptr_nv'>
	<parameter type-id='fe09dd29' name='target'/>
	<parameter type-id='79a0948f' name='bits'/>
	<return type-id='eaa32e2f'/>
	</function-decl>
	<function-decl name='atomic_sub_8_nv' mangled-name='atomic_sub_8_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_sub_8_nv'>
	<parameter type-id='aa323ea4' name='target'/>
	<parameter type-id='ee31ee44' name='bits'/>
	<return type-id='b96825af'/>
	</function-decl>
	- <function-decl name='atomic_sub_char_nv' mangled-name='atomic_sub_char_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_sub_char_nv'>
	- <parameter type-id='b663a671' name='target'/>
	- <parameter type-id='28577a57' name='bits'/>
	- <return type-id='d8bf0010'/>
	- </function-decl>
	<function-decl name='atomic_sub_16_nv' mangled-name='atomic_sub_16_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_sub_16_nv'>
	<parameter type-id='93977ae7' name='target'/>
	<parameter type-id='23bd8cb5' name='bits'/>
	<return type-id='149c6638'/>
	</function-decl>
	- <function-decl name='atomic_sub_short_nv' mangled-name='atomic_sub_short_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_sub_short_nv'>
	- <parameter type-id='8e6fdc53' name='target'/>
	- <parameter type-id='a2185560' name='bits'/>
	- <return type-id='d908a348'/>
	- </function-decl>
	<function-decl name='atomic_sub_32_nv' mangled-name='atomic_sub_32_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_sub_32_nv'>
	<parameter type-id='3a147f31' name='target'/>
	<parameter type-id='3ff5601b' name='bits'/>
	<return type-id='8f92235e'/>
	</function-decl>
	- <function-decl name='atomic_sub_int_nv' mangled-name='atomic_sub_int_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_sub_int_nv'>
	- <parameter type-id='0ea19dfa' name='target'/>
	- <parameter type-id='95e97e5e' name='bits'/>
	- <return type-id='3502e3ff'/>
	- </function-decl>
	<function-decl name='atomic_sub_long_nv' mangled-name='atomic_sub_long_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_sub_long_nv'>
	<parameter type-id='64698d33' name='target'/>
	<parameter type-id='bd54fe1a' name='bits'/>
	<return type-id='ee1f298e'/>
	</function-decl>
	- <function-decl name='atomic_sub_64_nv' mangled-name='atomic_sub_64_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_sub_64_nv'>
	- <parameter type-id='46a83d9c' name='target'/>
	- <parameter type-id='9da381c4' name='bits'/>
	- <return type-id='9c313c2d'/>
	- </function-decl>
	<function-decl name='atomic_sub_ptr_nv' mangled-name='atomic_sub_ptr_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_sub_ptr_nv'>
	<parameter type-id='fe09dd29' name='target'/>
	<parameter type-id='79a0948f' name='bits'/>
	<return type-id='eaa32e2f'/>
	</function-decl>
	<function-decl name='atomic_or_8_nv' mangled-name='atomic_or_8_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_or_8_nv'>
	<parameter type-id='aa323ea4' name='target'/>
	<parameter type-id='b96825af' name='bits'/>
	<return type-id='b96825af'/>
	</function-decl>
	- <function-decl name='atomic_or_uchar_nv' mangled-name='atomic_or_uchar_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_or_uchar_nv'>
	- <parameter type-id='b663a671' name='target'/>
	- <parameter type-id='d8bf0010' name='bits'/>
	- <return type-id='d8bf0010'/>
	- </function-decl>
	<function-decl name='atomic_or_16_nv' mangled-name='atomic_or_16_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_or_16_nv'>
	<parameter type-id='93977ae7' name='target'/>
	<parameter type-id='149c6638' name='bits'/>
	<return type-id='149c6638'/>
	</function-decl>
	- <function-decl name='atomic_or_ushort_nv' mangled-name='atomic_or_ushort_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_or_ushort_nv'>
	- <parameter type-id='8e6fdc53' name='target'/>
	- <parameter type-id='d908a348' name='bits'/>
	- <return type-id='d908a348'/>
	- </function-decl>
	<function-decl name='atomic_or_32_nv' mangled-name='atomic_or_32_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_or_32_nv'>
	<parameter type-id='3a147f31' name='target'/>
	<parameter type-id='8f92235e' name='bits'/>
	<return type-id='8f92235e'/>
	</function-decl>
	- <function-decl name='atomic_or_uint_nv' mangled-name='atomic_or_uint_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_or_uint_nv'>
	- <parameter type-id='0ea19dfa' name='target'/>
	- <parameter type-id='3502e3ff' name='bits'/>
	- <return type-id='3502e3ff'/>
	- </function-decl>
	<function-decl name='atomic_or_ulong_nv' mangled-name='atomic_or_ulong_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_or_ulong_nv'>
	<parameter type-id='64698d33' name='target'/>
	<parameter type-id='ee1f298e' name='bits'/>
	<return type-id='ee1f298e'/>
	</function-decl>
	- <function-decl name='atomic_or_64_nv' mangled-name='atomic_or_64_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_or_64_nv'>
	- <parameter type-id='46a83d9c' name='target'/>
	- <parameter type-id='9c313c2d' name='bits'/>
	- <return type-id='9c313c2d'/>
	- </function-decl>
	<function-decl name='atomic_and_8_nv' mangled-name='atomic_and_8_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_and_8_nv'>
	<parameter type-id='aa323ea4' name='target'/>
	<parameter type-id='b96825af' name='bits'/>
	<return type-id='b96825af'/>
	</function-decl>
	- <function-decl name='atomic_and_uchar_nv' mangled-name='atomic_and_uchar_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_and_uchar_nv'>
	- <parameter type-id='b663a671' name='target'/>
	- <parameter type-id='d8bf0010' name='bits'/>
	- <return type-id='d8bf0010'/>
	- </function-decl>
	<function-decl name='atomic_and_16_nv' mangled-name='atomic_and_16_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_and_16_nv'>
	<parameter type-id='93977ae7' name='target'/>
	<parameter type-id='149c6638' name='bits'/>
	<return type-id='149c6638'/>
	</function-decl>
	- <function-decl name='atomic_and_ushort_nv' mangled-name='atomic_and_ushort_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_and_ushort_nv'>
	- <parameter type-id='8e6fdc53' name='target'/>
	- <parameter type-id='d908a348' name='bits'/>
	- <return type-id='d908a348'/>
	- </function-decl>
	<function-decl name='atomic_and_32_nv' mangled-name='atomic_and_32_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_and_32_nv'>
	<parameter type-id='3a147f31' name='target'/>
	<parameter type-id='8f92235e' name='bits'/>
	<return type-id='8f92235e'/>
	</function-decl>
	- <function-decl name='atomic_and_uint_nv' mangled-name='atomic_and_uint_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_and_uint_nv'>
	- <parameter type-id='0ea19dfa' name='target'/>
	- <parameter type-id='3502e3ff' name='bits'/>
	- <return type-id='3502e3ff'/>
	- </function-decl>
	<function-decl name='atomic_and_ulong_nv' mangled-name='atomic_and_ulong_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_and_ulong_nv'>
	<parameter type-id='64698d33' name='target'/>
	<parameter type-id='ee1f298e' name='bits'/>
	<return type-id='ee1f298e'/>
	</function-decl>
	- <function-decl name='atomic_and_64_nv' mangled-name='atomic_and_64_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_and_64_nv'>
	- <parameter type-id='46a83d9c' name='target'/>
	- <parameter type-id='9c313c2d' name='bits'/>
	- <return type-id='9c313c2d'/>
	- </function-decl>
	<function-decl name='atomic_cas_8' mangled-name='atomic_cas_8' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_cas_8'>
	<parameter type-id='aa323ea4' name='target'/>
	<parameter type-id='b96825af' name='exp'/>
	<parameter type-id='b96825af' name='des'/>
	<return type-id='b96825af'/>
	</function-decl>
	- <function-decl name='atomic_cas_uchar' mangled-name='atomic_cas_uchar' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_cas_uchar'>
	- <parameter type-id='b663a671' name='target'/>
	- <parameter type-id='d8bf0010' name='exp'/>
	- <parameter type-id='d8bf0010' name='des'/>
	- <return type-id='d8bf0010'/>
	- </function-decl>
	<function-decl name='atomic_cas_16' mangled-name='atomic_cas_16' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_cas_16'>
	<parameter type-id='93977ae7' name='target'/>
	<parameter type-id='149c6638' name='exp'/>
	<parameter type-id='149c6638' name='des'/>
	<return type-id='149c6638'/>
	</function-decl>
	- <function-decl name='atomic_cas_ushort' mangled-name='atomic_cas_ushort' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_cas_ushort'>
	- <parameter type-id='8e6fdc53' name='target'/>
	- <parameter type-id='d908a348' name='exp'/>
	- <parameter type-id='d908a348' name='des'/>
	- <return type-id='d908a348'/>
	- </function-decl>
	<function-decl name='atomic_cas_32' mangled-name='atomic_cas_32' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_cas_32'>
	<parameter type-id='3a147f31' name='target'/>
	<parameter type-id='8f92235e' name='exp'/>
	<parameter type-id='8f92235e' name='des'/>
	<return type-id='8f92235e'/>
	</function-decl>
	- <function-decl name='atomic_cas_uint' mangled-name='atomic_cas_uint' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_cas_uint'>
	- <parameter type-id='0ea19dfa' name='target'/>
	- <parameter type-id='3502e3ff' name='exp'/>
	- <parameter type-id='3502e3ff' name='des'/>
	- <return type-id='3502e3ff'/>
	- </function-decl>
	<function-decl name='atomic_cas_ulong' mangled-name='atomic_cas_ulong' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_cas_ulong'>
	<parameter type-id='64698d33' name='target'/>
	<parameter type-id='ee1f298e' name='exp'/>
	<parameter type-id='ee1f298e' name='des'/>
	<return type-id='ee1f298e'/>
	</function-decl>
	- <function-decl name='atomic_cas_64' mangled-name='atomic_cas_64' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_cas_64'>
	- <parameter type-id='46a83d9c' name='target'/>
	- <parameter type-id='9c313c2d' name='exp'/>
	- <parameter type-id='9c313c2d' name='des'/>
	- <return type-id='9c313c2d'/>
	- </function-decl>
	<function-decl name='atomic_cas_ptr' mangled-name='atomic_cas_ptr' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_cas_ptr'>
	<parameter type-id='fe09dd29' name='target'/>
	<parameter type-id='eaa32e2f' name='exp'/>
	<parameter type-id='eaa32e2f' name='des'/>
	<return type-id='eaa32e2f'/>
	</function-decl>
	<function-decl name='atomic_swap_8' mangled-name='atomic_swap_8' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_swap_8'>
	<parameter type-id='aa323ea4' name='target'/>
	<parameter type-id='b96825af' name='bits'/>
	<return type-id='b96825af'/>
	</function-decl>
	- <function-decl name='atomic_swap_uchar' mangled-name='atomic_swap_uchar' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_swap_uchar'>
	- <parameter type-id='b663a671' name='target'/>
	- <parameter type-id='d8bf0010' name='bits'/>
	- <return type-id='d8bf0010'/>
	- </function-decl>
	<function-decl name='atomic_swap_16' mangled-name='atomic_swap_16' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_swap_16'>
	<parameter type-id='93977ae7' name='target'/>
	<parameter type-id='149c6638' name='bits'/>
	<return type-id='149c6638'/>
	</function-decl>
	- <function-decl name='atomic_swap_ushort' mangled-name='atomic_swap_ushort' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_swap_ushort'>
	- <parameter type-id='8e6fdc53' name='target'/>
	- <parameter type-id='d908a348' name='bits'/>
	- <return type-id='d908a348'/>
	- </function-decl>
	<function-decl name='atomic_swap_32' mangled-name='atomic_swap_32' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_swap_32'>
	<parameter type-id='3a147f31' name='target'/>
	<parameter type-id='8f92235e' name='bits'/>
	<return type-id='8f92235e'/>
	</function-decl>
	- <function-decl name='atomic_swap_uint' mangled-name='atomic_swap_uint' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_swap_uint'>
	- <parameter type-id='0ea19dfa' name='target'/>
	- <parameter type-id='3502e3ff' name='bits'/>
	- <return type-id='3502e3ff'/>
	- </function-decl>
	<function-decl name='atomic_swap_ulong' mangled-name='atomic_swap_ulong' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_swap_ulong'>
	<parameter type-id='64698d33' name='target'/>
	<parameter type-id='ee1f298e' name='bits'/>
	<return type-id='ee1f298e'/>
	</function-decl>
	- <function-decl name='atomic_swap_64' mangled-name='atomic_swap_64' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_swap_64'>
	- <parameter type-id='46a83d9c' name='target'/>
	- <parameter type-id='9c313c2d' name='bits'/>
	- <return type-id='9c313c2d'/>
	- </function-decl>
	<function-decl name='atomic_swap_ptr' mangled-name='atomic_swap_ptr' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_swap_ptr'>
	<parameter type-id='fe09dd29' name='target'/>
	<parameter type-id='eaa32e2f' name='bits'/>
	<return type-id='eaa32e2f'/>
	</function-decl>
	<function-decl name='atomic_set_long_excl' mangled-name='atomic_set_long_excl' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_set_long_excl'>
	<parameter type-id='64698d33' name='target'/>
	<parameter type-id='3502e3ff' name='value'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='atomic_clear_long_excl' mangled-name='atomic_clear_long_excl' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_clear_long_excl'>
	<parameter type-id='64698d33' name='target'/>
	<parameter type-id='3502e3ff' name='value'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='membar_enter' mangled-name='membar_enter' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='membar_enter'>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='membar_exit' mangled-name='membar_exit' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='membar_exit'>
	- <return type-id='48b5725f'/>
	- </function-decl>
	<function-decl name='membar_producer' mangled-name='membar_producer' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='membar_producer'>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='membar_consumer' mangled-name='membar_consumer' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='membar_consumer'>
	<return type-id='48b5725f'/>
	</function-decl>
	- <type-decl name='long int' size-in-bits='64' id='bd54fe1a'/>
	- <type-decl name='short int' size-in-bits='16' id='a2185560'/>
	- <type-decl name='signed char' size-in-bits='8' id='28577a57'/>
	- <typedef-decl name='int8_t' type-id='28577a57' id='ee31ee44'/>
	- <typedef-decl name='uint32_t' type-id='f0981eeb' id='8f92235e'/>
	- <typedef-decl name='uint8_t' type-id='002ac4a6' id='b96825af'/>
	- <typedef-decl name='uint_t' type-id='f0981eeb' id='3502e3ff'/>
	- <type-decl name='unsigned char' size-in-bits='8' id='002ac4a6'/>
	<type-decl name='unsigned short int' size-in-bits='16' id='8efea9e5'/>
	- <type-decl name='unsigned int' size-in-bits='32' id='f0981eeb'/>
	</abi-instr>
	- <abi-instr version='1.0' address-size='64' path='list.c' language='LANG_C89'>
	+ <abi-instr address-size='64' path='list.c' language='LANG_C99'>
	+ <typedef-decl name='list_node_t' type-id='b0b5e45e' id='b21843b2'/>
	<typedef-decl name='list_t' type-id='e824dae9' id='0899125f'/>
	+ <class-decl name='list_node' size-in-bits='128' is-struct='yes' visibility='default' id='b0b5e45e'>
	+ <data-member access='public' layout-offset-in-bits='0'>
	+ <var-decl name='next' type-id='b03eadb4' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='64'>
	+ <var-decl name='prev' type-id='b03eadb4' visibility='default'/>
	+ </data-member>
	+ </class-decl>
	<class-decl name='list' size-in-bits='256' is-struct='yes' visibility='default' id='e824dae9'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='list_size' type-id='b59d7dce' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='list_offset' type-id='b59d7dce' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='list_head' type-id='b0b5e45e' visibility='default'/>
	</data-member>
	</class-decl>
	- <class-decl name='list_node' size-in-bits='128' is-struct='yes' visibility='default' id='b0b5e45e'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='next' type-id='b03eadb4' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='prev' type-id='b03eadb4' visibility='default'/>
	- </data-member>
	- </class-decl>
	- <typedef-decl name='list_node_t' type-id='b0b5e45e' id='b21843b2'/>
	<pointer-type-def type-id='b0b5e45e' size-in-bits='64' id='b03eadb4'/>
	<pointer-type-def type-id='b21843b2' size-in-bits='64' id='ccc38265'/>
	<pointer-type-def type-id='0899125f' size-in-bits='64' id='352ec160'/>
	<function-decl name='list_create' mangled-name='list_create' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='list_create'>
	<parameter type-id='352ec160' name='list'/>
	<parameter type-id='b59d7dce' name='size'/>
	<parameter type-id='b59d7dce' name='offset'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='list_destroy' mangled-name='list_destroy' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='list_destroy'>
	<parameter type-id='352ec160' name='list'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='list_insert_head' mangled-name='list_insert_head' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='list_insert_head'>
	+ <function-decl name='list_insert_after' mangled-name='list_insert_after' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='list_insert_after'>
	<parameter type-id='352ec160' name='list'/>
	<parameter type-id='eaa32e2f' name='object'/>
	+ <parameter type-id='eaa32e2f' name='nobject'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='list_insert_after' mangled-name='list_insert_after' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='list_insert_after'>
	+ <function-decl name='list_insert_before' mangled-name='list_insert_before' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='list_insert_before'>
	<parameter type-id='352ec160' name='list'/>
	<parameter type-id='eaa32e2f' name='object'/>
	<parameter type-id='eaa32e2f' name='nobject'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='list_insert_tail' mangled-name='list_insert_tail' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='list_insert_tail'>
	+ <function-decl name='list_insert_head' mangled-name='list_insert_head' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='list_insert_head'>
	<parameter type-id='352ec160' name='list'/>
	<parameter type-id='eaa32e2f' name='object'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='list_insert_before' mangled-name='list_insert_before' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='list_insert_before'>
	+ <function-decl name='list_insert_tail' mangled-name='list_insert_tail' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='list_insert_tail'>
	<parameter type-id='352ec160' name='list'/>
	<parameter type-id='eaa32e2f' name='object'/>
	- <parameter type-id='eaa32e2f' name='nobject'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='list_remove' mangled-name='list_remove' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='list_remove'>
	<parameter type-id='352ec160' name='list'/>
	<parameter type-id='eaa32e2f' name='object'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='list_remove_head' mangled-name='list_remove_head' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='list_remove_head'>
	<parameter type-id='352ec160' name='list'/>
	<return type-id='eaa32e2f'/>
	</function-decl>
	<function-decl name='list_remove_tail' mangled-name='list_remove_tail' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='list_remove_tail'>
	<parameter type-id='352ec160' name='list'/>
	<return type-id='eaa32e2f'/>
	</function-decl>
	<function-decl name='list_head' mangled-name='list_head' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='list_head'>
	<parameter type-id='352ec160' name='list'/>
	<return type-id='eaa32e2f'/>
	</function-decl>
	<function-decl name='list_tail' mangled-name='list_tail' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='list_tail'>
	<parameter type-id='352ec160' name='list'/>
	<return type-id='eaa32e2f'/>
	</function-decl>
	<function-decl name='list_next' mangled-name='list_next' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='list_next'>
	<parameter type-id='352ec160' name='list'/>
	<parameter type-id='eaa32e2f' name='object'/>
	<return type-id='eaa32e2f'/>
	</function-decl>
	<function-decl name='list_prev' mangled-name='list_prev' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='list_prev'>
	<parameter type-id='352ec160' name='list'/>
	<parameter type-id='eaa32e2f' name='object'/>
	<return type-id='eaa32e2f'/>
	</function-decl>
	<function-decl name='list_move_tail' mangled-name='list_move_tail' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='list_move_tail'>
	<parameter type-id='352ec160' name='dst'/>
	<parameter type-id='352ec160' name='src'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='list_link_replace' mangled-name='list_link_replace' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='list_link_replace'>
	<parameter type-id='ccc38265' name='lold'/>
	<parameter type-id='ccc38265' name='lnew'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='list_link_init' mangled-name='list_link_init' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='list_link_init'>
	<parameter type-id='ccc38265' name='ln'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='list_link_active' mangled-name='list_link_active' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='list_link_active'>
	<parameter type-id='ccc38265' name='ln'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='list_is_empty' mangled-name='list_is_empty' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='list_is_empty'>
	<parameter type-id='352ec160' name='list'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	</abi-instr>
	- <abi-instr version='1.0' address-size='64' path='mkdirp.c' language='LANG_C89'>
	- <typedef-decl name='mode_t' type-id='e1c52942' id='d50d396c'/>
	+ <abi-instr address-size='64' path='mkdirp.c' language='LANG_C99'>
	<typedef-decl name='__mode_t' type-id='f0981eeb' id='e1c52942'/>
	+ <typedef-decl name='mode_t' type-id='e1c52942' id='d50d396c'/>
	<typedef-decl name='wchar_t' type-id='95e97e5e' id='928221d2'/>
	+ <qualified-type-def type-id='26a90f95' restrict='yes' id='266fe297'/>
	<qualified-type-def type-id='928221d2' const='yes' id='effb3702'/>
	<pointer-type-def type-id='effb3702' size-in-bits='64' id='f077d3f8'/>
	+ <qualified-type-def type-id='f077d3f8' restrict='yes' id='598aab80'/>
	<pointer-type-def type-id='928221d2' size-in-bits='64' id='323d93c1'/>
	+ <qualified-type-def type-id='323d93c1' restrict='yes' id='f1358bc3'/>
	<function-decl name='mkdirp' mangled-name='mkdirp' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='mkdirp'>
	<parameter type-id='80f4b756' name='d'/>
	<parameter type-id='d50d396c' name='mode'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='calloc' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='b59d7dce'/>
	<parameter type-id='b59d7dce'/>
	<return type-id='eaa32e2f'/>
	</function-decl>
	<function-decl name='mbstowcs' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='323d93c1'/>
	- <parameter type-id='80f4b756'/>
	+ <parameter type-id='f1358bc3'/>
	+ <parameter type-id='9d26089a'/>
	<parameter type-id='b59d7dce'/>
	<return type-id='b59d7dce'/>
	</function-decl>
	<function-decl name='wcstombs' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='26a90f95'/>
	- <parameter type-id='f077d3f8'/>
	+ <parameter type-id='266fe297'/>
	+ <parameter type-id='598aab80'/>
	<parameter type-id='b59d7dce'/>
	<return type-id='b59d7dce'/>
	</function-decl>
	<function-decl name='mkdir' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='80f4b756'/>
	<parameter type-id='e1c52942'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='access' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='80f4b756'/>
	<parameter type-id='95e97e5e'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='__rawmemchr' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='eaa32e2f'/>
	- <parameter type-id='95e97e5e'/>
	- <return type-id='eaa32e2f'/>
	- </function-decl>
	- <pointer-type-def type-id='a84c031d' size-in-bits='64' id='26a90f95'/>
	</abi-instr>
	- <abi-instr version='1.0' address-size='64' path='os/linux/getexecname.c' language='LANG_C89'>
	+ <abi-instr address-size='64' path='os/linux/getexecname.c' language='LANG_C99'>
	<function-decl name='readlink' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='26a90f95'/>
	+ <parameter type-id='9d26089a'/>
	+ <parameter type-id='266fe297'/>
	<parameter type-id='b59d7dce'/>
	<return type-id='79a0948f'/>
	</function-decl>
	</abi-instr>
	- <abi-instr version='1.0' address-size='64' path='os/linux/gethostid.c' language='LANG_C89'>
	+ <abi-instr address-size='64' path='os/linux/gethostid.c' language='LANG_C99'>
	<type-decl name='long long unsigned int' size-in-bits='64' id='3a47d82b'/>
	<pointer-type-def type-id='26a90f95' size-in-bits='64' id='9b23c9ad'/>
	- <function-decl name='get_system_hostid' mangled-name='get_system_hostid' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='get_system_hostid'>
	- <return type-id='7359adad'/>
	- </function-decl>
	- <function-decl name='getenv' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='80f4b756'/>
	- <return type-id='26a90f95'/>
	+ <qualified-type-def type-id='9b23c9ad' restrict='yes' id='8c85230f'/>
	+ <function-decl name='fclose' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='822cd80b'/>
	+ <return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='strtoull' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='9b23c9ad'/>
	+ <parameter type-id='9d26089a'/>
	+ <parameter type-id='8c85230f'/>
	<parameter type-id='95e97e5e'/>
	<return type-id='3a47d82b'/>
	</function-decl>
	- <function-decl name='fscanf' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='822cd80b'/>
	+ <function-decl name='getenv' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='80f4b756'/>
	- <parameter is-variadic='yes'/>
	- <return type-id='95e97e5e'/>
	+ <return type-id='26a90f95'/>
	</function-decl>
	- <function-decl name='fclose' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='822cd80b'/>
	+ <function-decl name='close' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='95e97e5e'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='read' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='95e97e5e'/>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='b59d7dce'/>
	<return type-id='79a0948f'/>
	</function-decl>
	- <function-decl name='close' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='95e97e5e'/>
	- <return type-id='95e97e5e'/>
	+ <function-decl name='get_system_hostid' mangled-name='get_system_hostid' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='get_system_hostid'>
	+ <return type-id='7359adad'/>
	</function-decl>
	- <pointer-type-def type-id='aa12d1ba' size-in-bits='64' id='822cd80b'/>
	- <typedef-decl name='FILE' type-id='ec1ed955' id='aa12d1ba'/>
	- <class-decl name='_IO_FILE' size-in-bits='1728' is-struct='yes' visibility='default' id='ec1ed955'>
	+ <type-decl name='unsigned long int' size-in-bits='64' id='7359adad'/>
	+ </abi-instr>
	+ <abi-instr address-size='64' path='os/linux/getmntany.c' language='LANG_C99'>
	+ <array-type-def dimensions='1' type-id='03085adc' size-in-bits='192' id='083f8d58'>
	+ <subrange length='3' type-id='7359adad' id='56f209d2'/>
	+ </array-type-def>
	+ <array-type-def dimensions='1' type-id='a84c031d' size-in-bits='32880' id='ad756b7f'>
	+ <subrange length='4110' type-id='7359adad' id='8aa676f7'/>
	+ </array-type-def>
	+ <class-decl name='mnttab' size-in-bits='256' is-struct='yes' visibility='default' id='1b055409'>
	<data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='_flags' type-id='95e97e5e' visibility='default'/>
	+ <var-decl name='mnt_special' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='_IO_read_ptr' type-id='26a90f95' visibility='default'/>
	+ <var-decl name='mnt_mountp' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='_IO_read_end' type-id='26a90f95' visibility='default'/>
	+ <var-decl name='mnt_fstype' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	- <var-decl name='_IO_read_base' type-id='26a90f95' visibility='default'/>
	+ <var-decl name='mnt_mntopts' type-id='26a90f95' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='256'>
	- <var-decl name='_IO_write_base' type-id='26a90f95' visibility='default'/>
	+ </class-decl>
	+ <class-decl name='extmnttab' size-in-bits='320' is-struct='yes' visibility='default' id='0c544dc0'>
	+ <data-member access='public' layout-offset-in-bits='0'>
	+ <var-decl name='mnt_special' type-id='26a90f95' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='320'>
	- <var-decl name='_IO_write_ptr' type-id='26a90f95' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='64'>
	+ <var-decl name='mnt_mountp' type-id='26a90f95' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='384'>
	- <var-decl name='_IO_write_end' type-id='26a90f95' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='448'>
	- <var-decl name='_IO_buf_base' type-id='26a90f95' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='512'>
	- <var-decl name='_IO_buf_end' type-id='26a90f95' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='576'>
	- <var-decl name='_IO_save_base' type-id='26a90f95' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='640'>
	- <var-decl name='_IO_backup_base' type-id='26a90f95' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='704'>
	- <var-decl name='_IO_save_end' type-id='26a90f95' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='768'>
	- <var-decl name='_markers' type-id='e4c6fa61' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='832'>
	- <var-decl name='_chain' type-id='dca988a5' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='896'>
	- <var-decl name='_fileno' type-id='95e97e5e' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='928'>
	- <var-decl name='_flags2' type-id='95e97e5e' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='960'>
	- <var-decl name='_old_offset' type-id='79989e9c' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='1024'>
	- <var-decl name='_cur_column' type-id='8efea9e5' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='1040'>
	- <var-decl name='_vtable_offset' type-id='28577a57' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='1048'>
	- <var-decl name='_shortbuf' type-id='89feb1ec' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='1088'>
	- <var-decl name='_lock' type-id='cecf4ea7' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='1152'>
	- <var-decl name='_offset' type-id='724e4de6' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='1216'>
	- <var-decl name='__pad1' type-id='eaa32e2f' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='1280'>
	- <var-decl name='__pad2' type-id='eaa32e2f' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='1344'>
	- <var-decl name='__pad3' type-id='eaa32e2f' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='1408'>
	- <var-decl name='__pad4' type-id='eaa32e2f' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='1472'>
	- <var-decl name='__pad5' type-id='b59d7dce' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='1536'>
	- <var-decl name='_mode' type-id='95e97e5e' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='1568'>
	- <var-decl name='_unused2' type-id='664ac0b7' visibility='default'/>
	- </data-member>
	- </class-decl>
	- <pointer-type-def type-id='ec1ed955' size-in-bits='64' id='dca988a5'/>
	- <pointer-type-def type-id='bb4788fa' size-in-bits='64' id='cecf4ea7'/>
	- <pointer-type-def type-id='010ae0b9' size-in-bits='64' id='e4c6fa61'/>
	- <array-type-def dimensions='1' type-id='a84c031d' size-in-bits='8' id='89feb1ec'>
	- <subrange length='1' type-id='4c87fef4' id='52f813b4'/>
	- </array-type-def>
	- <array-type-def dimensions='1' type-id='a84c031d' size-in-bits='160' id='664ac0b7'>
	- <subrange length='20' type-id='4c87fef4' id='fdca39cf'/>
	- </array-type-def>
	- <typedef-decl name='__off64_t' type-id='bd54fe1a' id='724e4de6'/>
	- <typedef-decl name='__off_t' type-id='bd54fe1a' id='79989e9c'/>
	- <class-decl name='_IO_marker' size-in-bits='192' is-struct='yes' visibility='default' id='010ae0b9'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='_next' type-id='e4c6fa61' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='_sbuf' type-id='dca988a5' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='_pos' type-id='95e97e5e' visibility='default'/>
	- </data-member>
	- </class-decl>
	- <typedef-decl name='_IO_lock_t' type-id='48b5725f' id='bb4788fa'/>
	- </abi-instr>
	- <abi-instr version='1.0' address-size='64' path='os/linux/getmntany.c' language='LANG_C89'>
	- <array-type-def dimensions='1' type-id='03085adc' size-in-bits='192' id='083f8d58'>
	- <subrange length='3' type-id='4c87fef4' id='56f209d2'/>
	- </array-type-def>
	- <array-type-def dimensions='1' type-id='a84c031d' size-in-bits='32880' id='ad756b7f'>
	- <subrange length='4110' type-id='4c87fef4' id='8aa676f7'/>
	- </array-type-def>
	- <class-decl name='mnttab' size-in-bits='256' is-struct='yes' visibility='default' id='1b055409'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='mnt_special' type-id='26a90f95' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='mnt_mountp' type-id='26a90f95' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='mnt_fstype' type-id='26a90f95' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='192'>
	- <var-decl name='mnt_mntopts' type-id='26a90f95' visibility='default'/>
	- </data-member>
	- </class-decl>
	- <class-decl name='extmnttab' size-in-bits='320' is-struct='yes' visibility='default' id='0c544dc0'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='mnt_special' type-id='26a90f95' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='mnt_mountp' type-id='26a90f95' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='mnt_fstype' type-id='26a90f95' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='128'>
	+ <var-decl name='mnt_fstype' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	<var-decl name='mnt_mntopts' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='256'>
	<var-decl name='mnt_major' type-id='3502e3ff' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='288'>
	<var-decl name='mnt_minor' type-id='3502e3ff' visibility='default'/>
	</data-member>
	</class-decl>
	<class-decl name='stat64' size-in-bits='1152' is-struct='yes' visibility='default' id='0bbec9cd'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='st_dev' type-id='35ed8932' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='st_ino' type-id='71288a47' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='st_nlink' type-id='80f0b9df' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	<var-decl name='st_mode' type-id='e1c52942' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='224'>
	<var-decl name='st_uid' type-id='cc5fcceb' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='256'>
	<var-decl name='st_gid' type-id='d94ec6d9' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='288'>
	<var-decl name='__pad0' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='320'>
	<var-decl name='st_rdev' type-id='35ed8932' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='384'>
	<var-decl name='st_size' type-id='79989e9c' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='448'>
	<var-decl name='st_blksize' type-id='d3f10a7f' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='512'>
	<var-decl name='st_blocks' type-id='4e711bf1' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='576'>
	<var-decl name='st_atim' type-id='a9c79a1f' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='704'>
	<var-decl name='st_mtim' type-id='a9c79a1f' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='832'>
	<var-decl name='st_ctim' type-id='a9c79a1f' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='960'>
	- <var-decl name='__unused' type-id='083f8d58' visibility='default'/>
	+ <var-decl name='__glibc_reserved' type-id='083f8d58' visibility='default'/>
	</data-member>
	</class-decl>
	<typedef-decl name='__dev_t' type-id='7359adad' id='35ed8932'/>
	- <typedef-decl name='__ino64_t' type-id='7359adad' id='71288a47'/>
	- <typedef-decl name='__nlink_t' type-id='7359adad' id='80f0b9df'/>
	<typedef-decl name='__uid_t' type-id='f0981eeb' id='cc5fcceb'/>
	<typedef-decl name='__gid_t' type-id='f0981eeb' id='d94ec6d9'/>
	+ <typedef-decl name='__ino64_t' type-id='7359adad' id='71288a47'/>
	+ <typedef-decl name='__nlink_t' type-id='7359adad' id='80f0b9df'/>
	<typedef-decl name='__blksize_t' type-id='bd54fe1a' id='d3f10a7f'/>
	<typedef-decl name='__blkcnt64_t' type-id='bd54fe1a' id='4e711bf1'/>
	<class-decl name='mntent' size-in-bits='320' is-struct='yes' visibility='default' id='56fe4a37'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='mnt_fsname' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='mnt_dir' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='mnt_type' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	<var-decl name='mnt_opts' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='256'>
	<var-decl name='mnt_freq' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='288'>
	<var-decl name='mnt_passno' type-id='95e97e5e' visibility='default'/>
	</data-member>
	</class-decl>
	<pointer-type-def type-id='0c544dc0' size-in-bits='64' id='394fc496'/>
	<pointer-type-def type-id='56fe4a37' size-in-bits='64' id='b6b61d2f'/>
	+ <qualified-type-def type-id='b6b61d2f' restrict='yes' id='3cad23cd'/>
	<pointer-type-def type-id='1b055409' size-in-bits='64' id='9d424d31'/>
	<pointer-type-def type-id='0bbec9cd' size-in-bits='64' id='62f7a03d'/>
	- <function-decl name='_sol_getmntent' mangled-name='_sol_getmntent' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_sol_getmntent'>
	- <parameter type-id='822cd80b' name='fp'/>
	- <parameter type-id='9d424d31' name='mgetp'/>
	+ <qualified-type-def type-id='62f7a03d' restrict='yes' id='f1cadedf'/>
	+ <function-decl name='getmntent_r' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='e75a27e9'/>
	+ <parameter type-id='3cad23cd'/>
	+ <parameter type-id='266fe297'/>
	+ <parameter type-id='95e97e5e'/>
	+ <return type-id='b6b61d2f'/>
	+ </function-decl>
	+ <function-decl name='feof' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='822cd80b'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	+ <function-decl name='stat64' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='9d26089a'/>
	+ <parameter type-id='f1cadedf'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <var-decl name='buf' type-id='ad756b7f' mangled-name='buf' visibility='default' elf-symbol-id='buf'/>
	<function-decl name='getmntany' mangled-name='getmntany' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='getmntany'>
	<parameter type-id='822cd80b' name='fp'/>
	<parameter type-id='9d424d31' name='mgetp'/>
	<parameter type-id='9d424d31' name='mrefp'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	+ <function-decl name='_sol_getmntent' mangled-name='_sol_getmntent' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_sol_getmntent'>
	+ <parameter type-id='822cd80b' name='fp'/>
	+ <parameter type-id='9d424d31' name='mgetp'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	<function-decl name='getextmntent' mangled-name='getextmntent' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='getextmntent'>
	<parameter type-id='80f4b756' name='path'/>
	<parameter type-id='394fc496' name='entry'/>
	<parameter type-id='62f7a03d' name='statbuf'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <var-decl name='buf' type-id='ad756b7f' mangled-name='buf' visibility='default' elf-symbol-id='buf'/>
	- <function-decl name='feof' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='822cd80b'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='getmntent_r' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='822cd80b'/>
	- <parameter type-id='b6b61d2f'/>
	- <parameter type-id='26a90f95'/>
	- <parameter type-id='95e97e5e'/>
	- <return type-id='b6b61d2f'/>
	- </function-decl>
	- <function-decl name='__xstat64' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='95e97e5e'/>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='62f7a03d'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <class-decl name='timespec' size-in-bits='128' is-struct='yes' visibility='default' id='a9c79a1f'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='tv_sec' type-id='65eda9c0' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='tv_nsec' type-id='03085adc' visibility='default'/>
	- </data-member>
	- </class-decl>
	- <typedef-decl name='__syscall_slong_t' type-id='bd54fe1a' id='03085adc'/>
	- <typedef-decl name='__time_t' type-id='bd54fe1a' id='65eda9c0'/>
	</abi-instr>
	- <abi-instr version='1.0' address-size='64' path='os/linux/zone.c' language='LANG_C89'>
	+ <abi-instr address-size='64' path='os/linux/zone.c' language='LANG_C99'>
	<typedef-decl name='zoneid_t' type-id='95e97e5e' id='4da03624'/>
	<function-decl name='getzoneid' mangled-name='getzoneid' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='getzoneid'>
	<return type-id='4da03624'/>
	</function-decl>
	</abi-instr>
	- <abi-instr version='1.0' address-size='64' path='page.c' language='LANG_C89'>
	+ <abi-instr address-size='64' path='page.c' language='LANG_C99'>
	+ <var-decl name='pagesize' type-id='b59d7dce' mangled-name='pagesize' visibility='default' elf-symbol-id='pagesize'/>
	<function-decl name='spl_pagesize' mangled-name='spl_pagesize' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='spl_pagesize'>
	<return type-id='b59d7dce'/>
	</function-decl>
	- <var-decl name='pagesize' type-id='b59d7dce' mangled-name='pagesize' visibility='default' elf-symbol-id='pagesize'/>
	<function-decl name='sysconf' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='95e97e5e'/>
	<return type-id='bd54fe1a'/>
	</function-decl>
	</abi-instr>
	- <abi-instr version='1.0' address-size='64' path='strlcat.c' language='LANG_C89'>
	+ <abi-instr address-size='64' path='strlcat.c' language='LANG_C99'>
	<function-decl name='strlcat' mangled-name='strlcat' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='strlcat'>
	<parameter type-id='26a90f95' name='dst'/>
	<parameter type-id='80f4b756' name='src'/>
	<parameter type-id='b59d7dce' name='dstsize'/>
	<return type-id='b59d7dce'/>
	</function-decl>
	</abi-instr>
	- <abi-instr version='1.0' address-size='64' path='timestamp.c' language='LANG_C89'>
	+ <abi-instr address-size='64' path='timestamp.c' language='LANG_C99'>
	<class-decl name='tm' size-in-bits='448' is-struct='yes' visibility='default' id='dddf6ca2'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='tm_sec' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='32'>
	<var-decl name='tm_min' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='tm_hour' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='96'>
	<var-decl name='tm_mday' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='tm_mon' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='160'>
	<var-decl name='tm_year' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	<var-decl name='tm_wday' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='224'>
	<var-decl name='tm_yday' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='256'>
	<var-decl name='tm_isdst' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='320'>
	<var-decl name='tm_gmtoff' type-id='bd54fe1a' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='384'>
	<var-decl name='tm_zone' type-id='80f4b756' visibility='default'/>
	</data-member>
	</class-decl>
	<typedef-decl name='time_t' type-id='65eda9c0' id='c9d12d66'/>
	<typedef-decl name='nl_item' type-id='95e97e5e' id='03b79a94'/>
	<qualified-type-def type-id='c9d12d66' const='yes' id='588b3216'/>
	<pointer-type-def type-id='588b3216' size-in-bits='64' id='9f201474'/>
	<qualified-type-def type-id='dddf6ca2' const='yes' id='e824a34f'/>
	<pointer-type-def type-id='e824a34f' size-in-bits='64' id='d6ad37ff'/>
	+ <qualified-type-def type-id='d6ad37ff' restrict='yes' id='f8c6051d'/>
	<pointer-type-def type-id='c9d12d66' size-in-bits='64' id='b2eb2c3f'/>
	<pointer-type-def type-id='dddf6ca2' size-in-bits='64' id='d915a820'/>
	<function-decl name='print_timestamp' mangled-name='print_timestamp' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='print_timestamp'>
	<parameter type-id='3502e3ff' name='timestamp_fmt'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='localtime' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='9f201474'/>
	- <return type-id='d915a820'/>
	+ <function-decl name='nl_langinfo' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='03b79a94'/>
	+ <return type-id='26a90f95'/>
	</function-decl>
	- <function-decl name='strftime' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='26a90f95'/>
	- <parameter type-id='b59d7dce'/>
	+ <function-decl name='printf' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='80f4b756'/>
	- <parameter type-id='d6ad37ff'/>
	- <return type-id='b59d7dce'/>
	+ <parameter is-variadic='yes'/>
	+ <return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='time' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='b2eb2c3f'/>
	<return type-id='c9d12d66'/>
	</function-decl>
	- <function-decl name='printf' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='80f4b756'/>
	- <parameter is-variadic='yes'/>
	- <return type-id='95e97e5e'/>
	+ <function-decl name='strftime' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='266fe297'/>
	+ <parameter type-id='b59d7dce'/>
	+ <parameter type-id='9d26089a'/>
	+ <parameter type-id='f8c6051d'/>
	+ <return type-id='b59d7dce'/>
	</function-decl>
	- <function-decl name='nl_langinfo' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='03b79a94'/>
	- <return type-id='26a90f95'/>
	+ <function-decl name='localtime' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='9f201474'/>
	+ <return type-id='d915a820'/>
	</function-decl>
	</abi-instr>
	- <abi-instr version='1.0' address-size='64' path='uu_alloc.c' language='LANG_C89'>
	+ <abi-instr address-size='64' path='uu_alloc.c' language='LANG_C99'>
	<type-decl name='char' size-in-bits='8' id='a84c031d'/>
	<class-decl name='__va_list_tag' size-in-bits='192' is-struct='yes' visibility='default' id='d5027220'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='gp_offset' type-id='f0981eeb' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='32'>
	<var-decl name='fp_offset' type-id='f0981eeb' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='overflow_arg_area' type-id='eaa32e2f' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='reg_save_area' type-id='eaa32e2f' visibility='default'/>
	</data-member>
	</class-decl>
	<type-decl name='int' size-in-bits='32' id='95e97e5e'/>
	<type-decl name='unsigned int' size-in-bits='32' id='f0981eeb'/>
	<type-decl name='unsigned long int' size-in-bits='64' id='7359adad'/>
	<type-decl name='variadic parameter type' id='2c1145c5'/>
	<type-decl name='void' id='48b5725f'/>
	- <typedef-decl name='size_t' type-id='7359adad' id='b59d7dce'/>
	<typedef-decl name='uint_t' type-id='f0981eeb' id='3502e3ff'/>
	+ <typedef-decl name='size_t' type-id='7359adad' id='b59d7dce'/>
	<pointer-type-def type-id='d5027220' size-in-bits='64' id='b7f2d5e6'/>
	<pointer-type-def type-id='a84c031d' size-in-bits='64' id='26a90f95'/>
	<qualified-type-def type-id='a84c031d' const='yes' id='9b45d938'/>
	<pointer-type-def type-id='9b45d938' size-in-bits='64' id='80f4b756'/>
	<pointer-type-def type-id='48b5725f' size-in-bits='64' id='eaa32e2f'/>
	+ <function-decl name='uu_set_error' mangled-name='uu_set_error' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_set_error'>
	+ <parameter type-id='3502e3ff'/>
	+ <return type-id='48b5725f'/>
	+ </function-decl>
	<function-decl name='uu_zalloc' mangled-name='uu_zalloc' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_zalloc'>
	<parameter type-id='b59d7dce' name='n'/>
	<return type-id='eaa32e2f'/>
	</function-decl>
	<function-decl name='uu_free' mangled-name='uu_free' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_free'>
	<parameter type-id='eaa32e2f' name='p'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='uu_strdup' mangled-name='uu_strdup' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_strdup'>
	<parameter type-id='80f4b756' name='str'/>
	<return type-id='26a90f95'/>
	</function-decl>
	<function-decl name='uu_strndup' mangled-name='uu_strndup' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_strndup'>
	<parameter type-id='80f4b756' name='s'/>
	<parameter type-id='b59d7dce' name='n'/>
	<return type-id='26a90f95'/>
	</function-decl>
	<function-decl name='uu_memdup' mangled-name='uu_memdup' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_memdup'>
	<parameter type-id='eaa32e2f' name='buf'/>
	<parameter type-id='b59d7dce' name='sz'/>
	<return type-id='eaa32e2f'/>
	</function-decl>
	<function-decl name='uu_msprintf' mangled-name='uu_msprintf' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_msprintf'>
	<parameter type-id='80f4b756' name='format'/>
	<parameter is-variadic='yes'/>
	<return type-id='26a90f95'/>
	</function-decl>
	+ <function-decl name='vsnprintf' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='26a90f95'/>
	+ <parameter type-id='b59d7dce'/>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='b7f2d5e6'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	<function-decl name='malloc' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='b59d7dce'/>
	<return type-id='eaa32e2f'/>
	</function-decl>
	- <function-decl name='uu_set_error' mangled-name='uu_set_error' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_set_error'>
	- <parameter type-id='3502e3ff'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	<function-decl name='free' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='eaa32e2f'/>
	<return type-id='48b5725f'/>
	</function-decl>
	+ <function-decl name='memcpy' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='eaa32e2f'/>
	+ <parameter type-id='eaa32e2f'/>
	+ <parameter type-id='b59d7dce'/>
	+ <return type-id='eaa32e2f'/>
	+ </function-decl>
	+ <function-decl name='memset' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='eaa32e2f'/>
	+ <parameter type-id='95e97e5e'/>
	+ <parameter type-id='b59d7dce'/>
	+ <return type-id='eaa32e2f'/>
	+ </function-decl>
	<function-decl name='strlen' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='80f4b756'/>
	<return type-id='b59d7dce'/>
	</function-decl>
	<function-decl name='strnlen' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='80f4b756'/>
	<parameter type-id='b59d7dce'/>
	<return type-id='b59d7dce'/>
	</function-decl>
	- <function-decl name='vsnprintf' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='26a90f95'/>
	- <parameter type-id='b59d7dce'/>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='b7f2d5e6'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	</abi-instr>
	- <abi-instr version='1.0' address-size='64' path='uu_avl.c' language='LANG_C89'>
	+ <abi-instr address-size='64' path='uu_avl.c' language='LANG_C99'>
	<array-type-def dimensions='1' type-id='bf311473' size-in-bits='128' id='f0f65199'>
	- <subrange length='2' type-id='4c87fef4' id='52efc4ef'/>
	+ <subrange length='2' type-id='7359adad' id='52efc4ef'/>
	</array-type-def>
	<array-type-def dimensions='1' type-id='a84c031d' size-in-bits='320' id='36c46961'>
	- <subrange length='40' type-id='4c87fef4' id='8f80b239'/>
	+ <subrange length='40' type-id='7359adad' id='8f80b239'/>
	</array-type-def>
	<array-type-def dimensions='1' type-id='a84c031d' size-in-bits='32' id='8e0573fd'>
	- <subrange length='4' type-id='4c87fef4' id='16fe7105'/>
	+ <subrange length='4' type-id='7359adad' id='16fe7105'/>
	</array-type-def>
	<array-type-def dimensions='1' type-id='a84c031d' size-in-bits='512' id='59daf3ef'>
	- <subrange length='64' type-id='4c87fef4' id='b10be967'/>
	+ <subrange length='64' type-id='7359adad' id='b10be967'/>
	</array-type-def>
	<type-decl name='long int' size-in-bits='64' id='bd54fe1a'/>
	<type-decl name='short int' size-in-bits='16' id='a2185560'/>
	<type-decl name='signed char' size-in-bits='8' id='28577a57'/>
	- <type-decl name='sizetype' size-in-bits='64' id='4c87fef4'/>
	<array-type-def dimensions='1' type-id='e475ab95' size-in-bits='192' id='0ce65a8b'>
	- <subrange length='3' type-id='4c87fef4' id='56f209d2'/>
	+ <subrange length='3' type-id='7359adad' id='56f209d2'/>
	</array-type-def>
	<type-decl name='unsigned char' size-in-bits='8' id='002ac4a6'/>
	- <class-decl name='uu_avl_pool' size-in-bits='2176' is-struct='yes' visibility='default' id='12a530a8'>
	+ <typedef-decl name='uu_compare_fn_t' type-id='add6e811' id='40f93560'/>
	+ <typedef-decl name='uu_walk_fn_t' type-id='96ee24a5' id='9d1aa0dc'/>
	+ <typedef-decl name='uu_avl_pool_t' type-id='12a530a8' id='7f84e390'/>
	+ <typedef-decl name='uu_avl_t' type-id='4af029d1' id='bb7f0973'/>
	+ <class-decl name='uu_avl_node' size-in-bits='192' is-struct='yes' visibility='default' id='f65f4326'>
	<data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='uap_next' type-id='de82c773' visibility='default'/>
	+ <var-decl name='uan_opaque' type-id='0ce65a8b' visibility='default'/>
	+ </data-member>
	+ </class-decl>
	+ <typedef-decl name='uu_avl_node_t' type-id='f65f4326' id='73a65116'/>
	+ <typedef-decl name='uu_avl_walk_t' type-id='e70a39e3' id='edd8457b'/>
	+ <typedef-decl name='uu_avl_index_t' type-id='e475ab95' id='5d7f5fc8'/>
	+ <class-decl name='uu_avl_walk' size-in-bits='320' is-struct='yes' visibility='default' id='e70a39e3'>
	+ <data-member access='public' layout-offset-in-bits='0'>
	+ <var-decl name='uaw_next' type-id='5842d146' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='uap_prev' type-id='de82c773' visibility='default'/>
	+ <var-decl name='uaw_prev' type-id='5842d146' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='uap_name' type-id='59daf3ef' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='640'>
	- <var-decl name='uap_nodeoffset' type-id='b59d7dce' visibility='default'/>
	+ <var-decl name='uaw_avl' type-id='a5c21a38' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='704'>
	- <var-decl name='uap_objsize' type-id='b59d7dce' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='192'>
	+ <var-decl name='uaw_next_result' type-id='eaa32e2f' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='768'>
	- <var-decl name='uap_cmp' type-id='d502b39f' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='256'>
	+ <var-decl name='uaw_dir' type-id='ee31ee44' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='832'>
	- <var-decl name='uap_debug' type-id='b96825af' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='264'>
	+ <var-decl name='uaw_robust' type-id='b96825af' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='840'>
	- <var-decl name='uap_last_index' type-id='b96825af' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='896'>
	- <var-decl name='uap_lock' type-id='7a6844eb' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='1216'>
	- <var-decl name='uap_null_avl' type-id='bb7f0973' visibility='default'/>
	- </data-member>
	- </class-decl>
	- <typedef-decl name='uu_avl_pool_t' type-id='12a530a8' id='7f84e390'/>
	- <typedef-decl name='uu_compare_fn_t' type-id='add6e811' id='40f93560'/>
	- <typedef-decl name='uint8_t' type-id='002ac4a6' id='b96825af'/>
	- <typedef-decl name='pthread_mutex_t' type-id='c4794498' id='7a6844eb'/>
	- <union-decl name='__anonymous_union__' size-in-bits='320' is-anonymous='yes' visibility='default' id='c4794498'>
	- <data-member access='private'>
	- <var-decl name='__data' type-id='4c734837' visibility='default'/>
	- </data-member>
	- <data-member access='private'>
	- <var-decl name='__size' type-id='36c46961' visibility='default'/>
	- </data-member>
	- <data-member access='private'>
	- <var-decl name='__align' type-id='bd54fe1a' visibility='default'/>
	- </data-member>
	- </union-decl>
	- <class-decl name='__pthread_mutex_s' size-in-bits='320' is-struct='yes' visibility='default' id='4c734837'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='__lock' type-id='95e97e5e' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='32'>
	- <var-decl name='__count' type-id='f0981eeb' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='__owner' type-id='95e97e5e' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='96'>
	- <var-decl name='__nusers' type-id='f0981eeb' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='__kind' type-id='95e97e5e' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='160'>
	- <var-decl name='__spins' type-id='a2185560' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='176'>
	- <var-decl name='__elision' type-id='a2185560' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='192'>
	- <var-decl name='__list' type-id='518fb49c' visibility='default'/>
	- </data-member>
	- </class-decl>
	- <typedef-decl name='__pthread_list_t' type-id='0e01899c' id='518fb49c'/>
	- <class-decl name='__pthread_internal_list' size-in-bits='128' is-struct='yes' visibility='default' id='0e01899c'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='__prev' type-id='4d98cd5a' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='__next' type-id='4d98cd5a' visibility='default'/>
	- </data-member>
	- </class-decl>
	- <class-decl name='uu_avl' size-in-bits='960' is-struct='yes' visibility='default' id='4af029d1'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='ua_next_enc' type-id='e475ab95' visibility='default'/>
	+ </class-decl>
	+ <class-decl name='uu_avl' size-in-bits='960' is-struct='yes' visibility='default' id='4af029d1'>
	+ <data-member access='public' layout-offset-in-bits='0'>
	+ <var-decl name='ua_next_enc' type-id='e475ab95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='ua_prev_enc' type-id='e475ab95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='ua_pool' type-id='de82c773' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	<var-decl name='ua_parent_enc' type-id='e475ab95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='256'>
	<var-decl name='ua_debug' type-id='b96825af' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='264'>
	<var-decl name='ua_index' type-id='b96825af' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='320'>
	<var-decl name='ua_tree' type-id='b351119f' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='640'>
	<var-decl name='ua_null_walk' type-id='edd8457b' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='uintptr_t' type-id='7359adad' id='e475ab95'/>
	- <class-decl name='avl_tree' size-in-bits='320' is-struct='yes' visibility='default' id='b351119f'>
	+ <class-decl name='uu_avl_pool' size-in-bits='2176' is-struct='yes' visibility='default' id='12a530a8'>
	<data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='avl_root' type-id='bf311473' visibility='default'/>
	+ <var-decl name='uap_next' type-id='de82c773' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='avl_compar' type-id='585e1de9' visibility='default'/>
	+ <var-decl name='uap_prev' type-id='de82c773' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='avl_offset' type-id='b59d7dce' visibility='default'/>
	+ <var-decl name='uap_name' type-id='59daf3ef' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='192'>
	- <var-decl name='avl_numnodes' type-id='ee1f298e' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='640'>
	+ <var-decl name='uap_nodeoffset' type-id='b59d7dce' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='256'>
	- <var-decl name='avl_size' type-id='b59d7dce' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='704'>
	+ <var-decl name='uap_objsize' type-id='b59d7dce' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='768'>
	+ <var-decl name='uap_cmp' type-id='d502b39f' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='832'>
	+ <var-decl name='uap_debug' type-id='b96825af' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='840'>
	+ <var-decl name='uap_last_index' type-id='b96825af' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='896'>
	+ <var-decl name='uap_lock' type-id='7a6844eb' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='1216'>
	+ <var-decl name='uap_null_avl' type-id='bb7f0973' visibility='default'/>
	</data-member>
	</class-decl>
	+ <typedef-decl name='avl_tree_t' type-id='b351119f' id='f20fbd51'/>
	+ <typedef-decl name='avl_index_t' type-id='e475ab95' id='fba6cb51'/>
	<class-decl name='avl_node' size-in-bits='192' is-struct='yes' visibility='default' id='428b67b3'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='avl_child' type-id='f0f65199' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='avl_pcb' type-id='e475ab95' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='ulong_t' type-id='7359adad' id='ee1f298e'/>
	- <class-decl name='uu_avl_walk' size-in-bits='320' is-struct='yes' visibility='default' id='e70a39e3'>
	+ <class-decl name='avl_tree' size-in-bits='320' is-struct='yes' visibility='default' id='b351119f'>
	<data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='uaw_next' type-id='5842d146' visibility='default'/>
	+ <var-decl name='avl_root' type-id='bf311473' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='uaw_prev' type-id='5842d146' visibility='default'/>
	+ <var-decl name='avl_compar' type-id='585e1de9' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='uaw_avl' type-id='a5c21a38' visibility='default'/>
	+ <var-decl name='avl_offset' type-id='b59d7dce' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	- <var-decl name='uaw_next_result' type-id='eaa32e2f' visibility='default'/>
	+ <var-decl name='avl_numnodes' type-id='ee1f298e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='256'>
	- <var-decl name='uaw_dir' type-id='ee31ee44' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='264'>
	- <var-decl name='uaw_robust' type-id='b96825af' visibility='default'/>
	- </data-member>
	- </class-decl>
	- <typedef-decl name='uu_avl_walk_t' type-id='e70a39e3' id='edd8457b'/>
	- <typedef-decl name='uu_avl_t' type-id='4af029d1' id='bb7f0973'/>
	- <typedef-decl name='int8_t' type-id='28577a57' id='ee31ee44'/>
	- <typedef-decl name='uint32_t' type-id='f0981eeb' id='8f92235e'/>
	- <typedef-decl name='uu_avl_node_t' type-id='f65f4326' id='73a65116'/>
	- <class-decl name='uu_avl_node' size-in-bits='192' is-struct='yes' visibility='default' id='f65f4326'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='uan_opaque' type-id='0ce65a8b' visibility='default'/>
	+ <var-decl name='avl_size' type-id='b59d7dce' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='uu_walk_fn_t' type-id='96ee24a5' id='9d1aa0dc'/>
	- <typedef-decl name='uu_avl_index_t' type-id='e475ab95' id='5d7f5fc8'/>
	- <typedef-decl name='avl_tree_t' type-id='b351119f' id='f20fbd51'/>
	- <typedef-decl name='pthread_mutexattr_t' type-id='e7fcd879' id='8afd6070'/>
	- <union-decl name='__anonymous_union__1' size-in-bits='32' is-anonymous='yes' visibility='default' id='e7fcd879'>
	- <data-member access='private'>
	+ <typedef-decl name='ulong_t' type-id='7359adad' id='ee1f298e'/>
	+ <union-decl name='pthread_mutexattr_t' size-in-bits='32' naming-typedef-id='8afd6070' visibility='default' id='7300eb00'>
	+ <data-member access='public'>
	<var-decl name='__size' type-id='8e0573fd' visibility='default'/>
	</data-member>
	- <data-member access='private'>
	+ <data-member access='public'>
	<var-decl name='__align' type-id='95e97e5e' visibility='default'/>
	</data-member>
	</union-decl>
	- <typedef-decl name='avl_index_t' type-id='e475ab95' id='fba6cb51'/>
	+ <typedef-decl name='pthread_mutexattr_t' type-id='7300eb00' id='8afd6070'/>
	+ <union-decl name='pthread_mutex_t' size-in-bits='320' naming-typedef-id='7a6844eb' visibility='default' id='70681f9b'>
	+ <data-member access='public'>
	+ <var-decl name='__data' type-id='4c734837' visibility='default'/>
	+ </data-member>
	+ <data-member access='public'>
	+ <var-decl name='__size' type-id='36c46961' visibility='default'/>
	+ </data-member>
	+ <data-member access='public'>
	+ <var-decl name='__align' type-id='bd54fe1a' visibility='default'/>
	+ </data-member>
	+ </union-decl>
	+ <typedef-decl name='pthread_mutex_t' type-id='70681f9b' id='7a6844eb'/>
	+ <typedef-decl name='int8_t' type-id='2171a512' id='ee31ee44'/>
	+ <typedef-decl name='uint8_t' type-id='c51d6389' id='b96825af'/>
	+ <typedef-decl name='uint32_t' type-id='62f1140c' id='8f92235e'/>
	+ <class-decl name='__pthread_mutex_s' size-in-bits='320' is-struct='yes' visibility='default' id='4c734837'>
	+ <data-member access='public' layout-offset-in-bits='0'>
	+ <var-decl name='__lock' type-id='95e97e5e' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='32'>
	+ <var-decl name='__count' type-id='f0981eeb' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='64'>
	+ <var-decl name='__owner' type-id='95e97e5e' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='96'>
	+ <var-decl name='__nusers' type-id='f0981eeb' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='128'>
	+ <var-decl name='__kind' type-id='95e97e5e' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='160'>
	+ <var-decl name='__spins' type-id='a2185560' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='176'>
	+ <var-decl name='__elision' type-id='a2185560' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='192'>
	+ <var-decl name='__list' type-id='518fb49c' visibility='default'/>
	+ </data-member>
	+ </class-decl>
	+ <class-decl name='__pthread_internal_list' size-in-bits='128' is-struct='yes' visibility='default' id='0e01899c'>
	+ <data-member access='public' layout-offset-in-bits='0'>
	+ <var-decl name='__prev' type-id='4d98cd5a' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='64'>
	+ <var-decl name='__next' type-id='4d98cd5a' visibility='default'/>
	+ </data-member>
	+ </class-decl>
	+ <typedef-decl name='__pthread_list_t' type-id='0e01899c' id='518fb49c'/>
	+ <typedef-decl name='__int8_t' type-id='28577a57' id='2171a512'/>
	+ <typedef-decl name='__uint8_t' type-id='002ac4a6' id='c51d6389'/>
	+ <typedef-decl name='__uint32_t' type-id='f0981eeb' id='62f1140c'/>
	+ <typedef-decl name='uintptr_t' type-id='7359adad' id='e475ab95'/>
	<pointer-type-def type-id='0e01899c' size-in-bits='64' id='4d98cd5a'/>
	<pointer-type-def type-id='fba6cb51' size-in-bits='64' id='32adbf30'/>
	<pointer-type-def type-id='428b67b3' size-in-bits='64' id='bf311473'/>
	<pointer-type-def type-id='b351119f' size-in-bits='64' id='716943c7'/>
	<pointer-type-def type-id='f20fbd51' size-in-bits='64' id='a3681dea'/>
	<qualified-type-def type-id='8afd6070' const='yes' id='1d853360'/>
	<pointer-type-def type-id='1d853360' size-in-bits='64' id='c2afbd7e'/>
	<pointer-type-def type-id='96ee24a5' size-in-bits='64' id='585e1de9'/>
	<pointer-type-def type-id='7a6844eb' size-in-bits='64' id='18c91f9e'/>
	<pointer-type-def type-id='5d7f5fc8' size-in-bits='64' id='813a2225'/>
	<pointer-type-def type-id='73a65116' size-in-bits='64' id='2dc35b9d'/>
	<pointer-type-def type-id='7f84e390' size-in-bits='64' id='de82c773'/>
	<pointer-type-def type-id='bb7f0973' size-in-bits='64' id='a5c21a38'/>
	<pointer-type-def type-id='edd8457b' size-in-bits='64' id='5842d146'/>
	<pointer-type-def type-id='40f93560' size-in-bits='64' id='d502b39f'/>
	<pointer-type-def type-id='9d1aa0dc' size-in-bits='64' id='30a42b6d'/>
	<pointer-type-def type-id='eaa32e2f' size-in-bits='64' id='63e171df'/>
	+ <function-decl name='uu_check_name' mangled-name='uu_check_name' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_check_name'>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='3502e3ff'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='uu_panic' mangled-name='uu_panic' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_panic'>
	+ <parameter type-id='80f4b756'/>
	+ <parameter is-variadic='yes'/>
	+ <return type-id='48b5725f'/>
	+ </function-decl>
	+ <function-decl name='avl_create' mangled-name='avl_create' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='avl_create'>
	+ <parameter type-id='a3681dea'/>
	+ <parameter type-id='585e1de9'/>
	+ <parameter type-id='b59d7dce'/>
	+ <parameter type-id='b59d7dce'/>
	+ <return type-id='48b5725f'/>
	+ </function-decl>
	+ <function-decl name='avl_find' mangled-name='avl_find' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='avl_find'>
	+ <parameter type-id='a3681dea'/>
	+ <parameter type-id='eaa32e2f'/>
	+ <parameter type-id='32adbf30'/>
	+ <return type-id='eaa32e2f'/>
	+ </function-decl>
	+ <function-decl name='avl_insert' mangled-name='avl_insert' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='avl_insert'>
	+ <parameter type-id='a3681dea'/>
	+ <parameter type-id='eaa32e2f'/>
	+ <parameter type-id='fba6cb51'/>
	+ <return type-id='48b5725f'/>
	+ </function-decl>
	+ <function-decl name='avl_first' mangled-name='avl_first' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='avl_first'>
	+ <parameter type-id='a3681dea'/>
	+ <return type-id='eaa32e2f'/>
	+ </function-decl>
	+ <function-decl name='avl_last' mangled-name='avl_last' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='avl_last'>
	+ <parameter type-id='a3681dea'/>
	+ <return type-id='eaa32e2f'/>
	+ </function-decl>
	+ <function-decl name='avl_nearest' mangled-name='avl_nearest' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='avl_nearest'>
	+ <parameter type-id='a3681dea'/>
	+ <parameter type-id='fba6cb51'/>
	+ <parameter type-id='95e97e5e'/>
	+ <return type-id='eaa32e2f'/>
	+ </function-decl>
	+ <function-decl name='avl_remove' mangled-name='avl_remove' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='avl_remove'>
	+ <parameter type-id='a3681dea'/>
	+ <parameter type-id='eaa32e2f'/>
	+ <return type-id='48b5725f'/>
	+ </function-decl>
	+ <function-decl name='avl_numnodes' mangled-name='avl_numnodes' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='avl_numnodes'>
	+ <parameter type-id='a3681dea'/>
	+ <return type-id='ee1f298e'/>
	+ </function-decl>
	+ <function-decl name='avl_destroy_nodes' mangled-name='avl_destroy_nodes' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='avl_destroy_nodes'>
	+ <parameter type-id='a3681dea'/>
	+ <parameter type-id='63e171df'/>
	+ <return type-id='eaa32e2f'/>
	+ </function-decl>
	+ <function-decl name='avl_destroy' mangled-name='avl_destroy' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='avl_destroy'>
	+ <parameter type-id='a3681dea'/>
	+ <return type-id='48b5725f'/>
	+ </function-decl>
	+ <function-decl name='avl_walk' mangled-name='avl_walk' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='avl_walk'>
	+ <parameter type-id='716943c7'/>
	+ <parameter type-id='eaa32e2f'/>
	+ <parameter type-id='95e97e5e'/>
	+ <return type-id='eaa32e2f'/>
	+ </function-decl>
	+ <function-decl name='strlcpy' mangled-name='strlcpy' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='strlcpy'>
	+ <parameter type-id='26a90f95'/>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='b59d7dce'/>
	+ <return type-id='b59d7dce'/>
	+ </function-decl>
	<function-decl name='uu_avl_pool_create' mangled-name='uu_avl_pool_create' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_avl_pool_create'>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='b59d7dce' name='objsize'/>
	<parameter type-id='b59d7dce' name='nodeoffset'/>
	<parameter type-id='d502b39f' name='compare_func'/>
	<parameter type-id='8f92235e' name='flags'/>
	<return type-id='de82c773'/>
	</function-decl>
	<function-decl name='uu_avl_pool_destroy' mangled-name='uu_avl_pool_destroy' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_avl_pool_destroy'>
	<parameter type-id='de82c773' name='pp'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='uu_avl_node_init' mangled-name='uu_avl_node_init' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_avl_node_init'>
	<parameter type-id='eaa32e2f' name='base'/>
	<parameter type-id='2dc35b9d' name='np'/>
	<parameter type-id='de82c773' name='pp'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='uu_avl_node_fini' mangled-name='uu_avl_node_fini' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_avl_node_fini'>
	<parameter type-id='eaa32e2f' name='base'/>
	<parameter type-id='2dc35b9d' name='np'/>
	<parameter type-id='de82c773' name='pp'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='uu_avl_create' mangled-name='uu_avl_create' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_avl_create'>
	<parameter type-id='de82c773' name='pp'/>
	<parameter type-id='eaa32e2f' name='parent'/>
	<parameter type-id='8f92235e' name='flags'/>
	<return type-id='a5c21a38'/>
	</function-decl>
	<function-decl name='uu_avl_destroy' mangled-name='uu_avl_destroy' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_avl_destroy'>
	<parameter type-id='a5c21a38' name='ap'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='uu_avl_numnodes' mangled-name='uu_avl_numnodes' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_avl_numnodes'>
	<parameter type-id='a5c21a38' name='ap'/>
	<return type-id='b59d7dce'/>
	</function-decl>
	<function-decl name='uu_avl_first' mangled-name='uu_avl_first' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_avl_first'>
	<parameter type-id='a5c21a38' name='ap'/>
	<return type-id='eaa32e2f'/>
	</function-decl>
	<function-decl name='uu_avl_last' mangled-name='uu_avl_last' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_avl_last'>
	<parameter type-id='a5c21a38' name='ap'/>
	<return type-id='eaa32e2f'/>
	</function-decl>
	<function-decl name='uu_avl_next' mangled-name='uu_avl_next' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_avl_next'>
	<parameter type-id='a5c21a38' name='ap'/>
	<parameter type-id='eaa32e2f' name='node'/>
	<return type-id='eaa32e2f'/>
	</function-decl>
	<function-decl name='uu_avl_prev' mangled-name='uu_avl_prev' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_avl_prev'>
	<parameter type-id='a5c21a38' name='ap'/>
	<parameter type-id='eaa32e2f' name='node'/>
	<return type-id='eaa32e2f'/>
	</function-decl>
	<function-decl name='uu_avl_walk_start' mangled-name='uu_avl_walk_start' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_avl_walk_start'>
	<parameter type-id='a5c21a38' name='ap'/>
	<parameter type-id='8f92235e' name='flags'/>
	<return type-id='5842d146'/>
	</function-decl>
	<function-decl name='uu_avl_walk_next' mangled-name='uu_avl_walk_next' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_avl_walk_next'>
	<parameter type-id='5842d146' name='wp'/>
	<return type-id='eaa32e2f'/>
	</function-decl>
	<function-decl name='uu_avl_walk_end' mangled-name='uu_avl_walk_end' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_avl_walk_end'>
	<parameter type-id='5842d146' name='wp'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='uu_avl_walk' mangled-name='uu_avl_walk' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_avl_walk'>
	<parameter type-id='a5c21a38' name='ap'/>
	<parameter type-id='30a42b6d' name='func'/>
	<parameter type-id='eaa32e2f' name='private'/>
	<parameter type-id='8f92235e' name='flags'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='uu_avl_remove' mangled-name='uu_avl_remove' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_avl_remove'>
	<parameter type-id='a5c21a38' name='ap'/>
	<parameter type-id='eaa32e2f' name='elem'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='uu_avl_teardown' mangled-name='uu_avl_teardown' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_avl_teardown'>
	<parameter type-id='a5c21a38' name='ap'/>
	<parameter type-id='63e171df' name='cookie'/>
	<return type-id='eaa32e2f'/>
	</function-decl>
	<function-decl name='uu_avl_find' mangled-name='uu_avl_find' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_avl_find'>
	<parameter type-id='a5c21a38' name='ap'/>
	<parameter type-id='eaa32e2f' name='elem'/>
	<parameter type-id='eaa32e2f' name='private'/>
	<parameter type-id='813a2225' name='out'/>
	<return type-id='eaa32e2f'/>
	</function-decl>
	<function-decl name='uu_avl_insert' mangled-name='uu_avl_insert' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_avl_insert'>
	<parameter type-id='a5c21a38' name='ap'/>
	<parameter type-id='eaa32e2f' name='elem'/>
	<parameter type-id='5d7f5fc8' name='idx'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='uu_avl_nearest_next' mangled-name='uu_avl_nearest_next' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_avl_nearest_next'>
	<parameter type-id='a5c21a38' name='ap'/>
	<parameter type-id='5d7f5fc8' name='idx'/>
	<return type-id='eaa32e2f'/>
	</function-decl>
	<function-decl name='uu_avl_nearest_prev' mangled-name='uu_avl_nearest_prev' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_avl_nearest_prev'>
	<parameter type-id='a5c21a38' name='ap'/>
	- <parameter type-id='5d7f5fc8' name='idx'/>
	- <return type-id='eaa32e2f'/>
	- </function-decl>
	- <function-decl name='uu_avl_lockup' mangled-name='uu_avl_lockup' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_avl_lockup'>
	- <return type-id='48b5725f'/>
	- </function-decl>
	- <function-decl name='uu_avl_release' mangled-name='uu_avl_release' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_avl_release'>
	- <return type-id='48b5725f'/>
	- </function-decl>
	- <function-decl name='avl_last' mangled-name='avl_last' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='avl_last'>
	- <parameter type-id='a3681dea'/>
	- <return type-id='eaa32e2f'/>
	- </function-decl>
	- <function-decl name='avl_first' mangled-name='avl_first' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='avl_first'>
	- <parameter type-id='a3681dea'/>
	- <return type-id='eaa32e2f'/>
	- </function-decl>
	- <function-decl name='avl_walk' mangled-name='avl_walk' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='avl_walk'>
	- <parameter type-id='716943c7'/>
	- <parameter type-id='eaa32e2f'/>
	- <parameter type-id='95e97e5e'/>
	- <return type-id='eaa32e2f'/>
	- </function-decl>
	- <function-decl name='uu_check_name' mangled-name='uu_check_name' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_check_name'>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='3502e3ff'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='strlcpy' mangled-name='strlcpy' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='strlcpy'>
	- <parameter type-id='26a90f95'/>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='b59d7dce'/>
	- <return type-id='b59d7dce'/>
	- </function-decl>
	- <function-decl name='pthread_mutex_init' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='18c91f9e'/>
	- <parameter type-id='c2afbd7e'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='pthread_mutex_lock' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='18c91f9e'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='pthread_mutex_unlock' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='18c91f9e'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='uu_panic' mangled-name='uu_panic' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_panic'>
	- <parameter type-id='80f4b756'/>
	- <parameter is-variadic='yes'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	- <function-decl name='pthread_mutex_destroy' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='18c91f9e'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='avl_create' mangled-name='avl_create' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='avl_create'>
	- <parameter type-id='a3681dea'/>
	- <parameter type-id='585e1de9'/>
	- <parameter type-id='b59d7dce'/>
	- <parameter type-id='b59d7dce'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	- <function-decl name='avl_destroy' mangled-name='avl_destroy' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='avl_destroy'>
	- <parameter type-id='a3681dea'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	- <function-decl name='avl_numnodes' mangled-name='avl_numnodes' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='avl_numnodes'>
	- <parameter type-id='a3681dea'/>
	- <return type-id='ee1f298e'/>
	- </function-decl>
	- <function-decl name='avl_remove' mangled-name='avl_remove' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='avl_remove'>
	- <parameter type-id='a3681dea'/>
	- <parameter type-id='eaa32e2f'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	- <function-decl name='avl_destroy_nodes' mangled-name='avl_destroy_nodes' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='avl_destroy_nodes'>
	- <parameter type-id='a3681dea'/>
	- <parameter type-id='63e171df'/>
	- <return type-id='eaa32e2f'/>
	- </function-decl>
	- <function-decl name='avl_find' mangled-name='avl_find' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='avl_find'>
	- <parameter type-id='a3681dea'/>
	- <parameter type-id='eaa32e2f'/>
	- <parameter type-id='32adbf30'/>
	+ <parameter type-id='5d7f5fc8' name='idx'/>
	<return type-id='eaa32e2f'/>
	</function-decl>
	- <function-decl name='avl_insert' mangled-name='avl_insert' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='avl_insert'>
	- <parameter type-id='a3681dea'/>
	- <parameter type-id='eaa32e2f'/>
	- <parameter type-id='fba6cb51'/>
	+ <function-decl name='uu_avl_lockup' mangled-name='uu_avl_lockup' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_avl_lockup'>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='avl_nearest' mangled-name='avl_nearest' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='avl_nearest'>
	- <parameter type-id='a3681dea'/>
	- <parameter type-id='fba6cb51'/>
	- <parameter type-id='95e97e5e'/>
	- <return type-id='eaa32e2f'/>
	+ <function-decl name='uu_avl_release' mangled-name='uu_avl_release' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_avl_release'>
	+ <return type-id='48b5725f'/>
	+ </function-decl>
	+ <function-decl name='pthread_mutex_init' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='18c91f9e'/>
	+ <parameter type-id='c2afbd7e'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='pthread_mutex_destroy' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='18c91f9e'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='pthread_mutex_lock' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='18c91f9e'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='pthread_mutex_unlock' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='18c91f9e'/>
	+ <return type-id='95e97e5e'/>
	</function-decl>
	<function-type size-in-bits='64' id='96ee24a5'>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='eaa32e2f'/>
	<return type-id='95e97e5e'/>
	</function-type>
	<function-type size-in-bits='64' id='add6e811'>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='eaa32e2f'/>
	<return type-id='95e97e5e'/>
	</function-type>
	</abi-instr>
	- <abi-instr version='1.0' address-size='64' path='uu_dprintf.c' language='LANG_C89'>
	+ <abi-instr address-size='64' path='uu_dprintf.c' language='LANG_C99'>
	<array-type-def dimensions='1' type-id='a84c031d' size-in-bits='8' id='89feb1ec'>
	- <subrange length='1' type-id='4c87fef4' id='52f813b4'/>
	+ <subrange length='1' type-id='7359adad' id='52f813b4'/>
	</array-type-def>
	<array-type-def dimensions='1' type-id='a84c031d' size-in-bits='160' id='664ac0b7'>
	- <subrange length='20' type-id='4c87fef4' id='fdca39cf'/>
	+ <subrange length='20' type-id='7359adad' id='fdca39cf'/>
	</array-type-def>
	+ <class-decl name='_IO_codecvt' is-struct='yes' visibility='default' is-declaration-only='yes' id='a4036571'/>
	+ <class-decl name='_IO_marker' is-struct='yes' visibility='default' is-declaration-only='yes' id='010ae0b9'/>
	+ <class-decl name='_IO_wide_data' is-struct='yes' visibility='default' is-declaration-only='yes' id='79bd3751'/>
	<type-decl name='unnamed-enum-underlying-type-32' is-anonymous='yes' size-in-bits='32' alignment-in-bits='32' id='9cac1fee'/>
	<type-decl name='unsigned short int' size-in-bits='16' id='8efea9e5'/>
	<typedef-decl name='uu_dprintf_t' type-id='0538fe4f' id='2367d595'/>
	+ <enum-decl name='uu_dprintf_severity_t' naming-typedef-id='ceb5296f' id='c43e6e7b'>
	+ <underlying-type type-id='9cac1fee'/>
	+ <enumerator name='UU_DPRINTF_SILENT' value='0'/>
	+ <enumerator name='UU_DPRINTF_FATAL' value='1'/>
	+ <enumerator name='UU_DPRINTF_WARNING' value='2'/>
	+ <enumerator name='UU_DPRINTF_NOTICE' value='3'/>
	+ <enumerator name='UU_DPRINTF_INFO' value='4'/>
	+ <enumerator name='UU_DPRINTF_DEBUG' value='5'/>
	+ </enum-decl>
	+ <typedef-decl name='uu_dprintf_severity_t' type-id='c43e6e7b' id='ceb5296f'/>
	<class-decl name='uu_dprintf' size-in-bits='128' is-struct='yes' visibility='default' id='0538fe4f'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='uud_name' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='uud_severity' type-id='ceb5296f' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='96'>
	<var-decl name='uud_flags' type-id='3502e3ff' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='uu_dprintf_severity_t' type-id='08f5ca18' id='ceb5296f'/>
	- <enum-decl name='__anonymous_enum__' is-anonymous='yes' id='08f5ca18'>
	- <underlying-type type-id='9cac1fee'/>
	- <enumerator name='UU_DPRINTF_SILENT' value='0'/>
	- <enumerator name='UU_DPRINTF_FATAL' value='1'/>
	- <enumerator name='UU_DPRINTF_WARNING' value='2'/>
	- <enumerator name='UU_DPRINTF_NOTICE' value='3'/>
	- <enumerator name='UU_DPRINTF_INFO' value='4'/>
	- <enumerator name='UU_DPRINTF_DEBUG' value='5'/>
	- </enum-decl>
	+ <typedef-decl name='__off_t' type-id='bd54fe1a' id='79989e9c'/>
	+ <typedef-decl name='__off64_t' type-id='bd54fe1a' id='724e4de6'/>
	<typedef-decl name='FILE' type-id='ec1ed955' id='aa12d1ba'/>
	+ <typedef-decl name='_IO_lock_t' type-id='48b5725f' id='bb4788fa'/>
	<class-decl name='_IO_FILE' size-in-bits='1728' is-struct='yes' visibility='default' id='ec1ed955'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='_flags' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='_IO_read_ptr' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='_IO_read_end' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	<var-decl name='_IO_read_base' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='256'>
	<var-decl name='_IO_write_base' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='320'>
	<var-decl name='_IO_write_ptr' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='384'>
	<var-decl name='_IO_write_end' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='448'>
	<var-decl name='_IO_buf_base' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='512'>
	<var-decl name='_IO_buf_end' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='576'>
	<var-decl name='_IO_save_base' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='640'>
	<var-decl name='_IO_backup_base' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='704'>
	<var-decl name='_IO_save_end' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='768'>
	<var-decl name='_markers' type-id='e4c6fa61' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='832'>
	<var-decl name='_chain' type-id='dca988a5' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='896'>
	<var-decl name='_fileno' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='928'>
	<var-decl name='_flags2' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='960'>
	<var-decl name='_old_offset' type-id='79989e9c' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='1024'>
	<var-decl name='_cur_column' type-id='8efea9e5' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='1040'>
	<var-decl name='_vtable_offset' type-id='28577a57' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='1048'>
	<var-decl name='_shortbuf' type-id='89feb1ec' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='1088'>
	<var-decl name='_lock' type-id='cecf4ea7' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='1152'>
	<var-decl name='_offset' type-id='724e4de6' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='1216'>
	- <var-decl name='__pad1' type-id='eaa32e2f' visibility='default'/>
	+ <var-decl name='_codecvt' type-id='570f8c59' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='1280'>
	- <var-decl name='__pad2' type-id='eaa32e2f' visibility='default'/>
	+ <var-decl name='_wide_data' type-id='c65a1f29' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='1344'>
	- <var-decl name='__pad3' type-id='eaa32e2f' visibility='default'/>
	+ <var-decl name='_freeres_list' type-id='dca988a5' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='1408'>
	- <var-decl name='__pad4' type-id='eaa32e2f' visibility='default'/>
	+ <var-decl name='_freeres_buf' type-id='eaa32e2f' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='1472'>
	<var-decl name='__pad5' type-id='b59d7dce' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='1536'>
	<var-decl name='_mode' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='1568'>
	<var-decl name='_unused2' type-id='664ac0b7' visibility='default'/>
	</data-member>
	</class-decl>
	- <class-decl name='_IO_marker' size-in-bits='192' is-struct='yes' visibility='default' id='010ae0b9'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='_next' type-id='e4c6fa61' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='_sbuf' type-id='dca988a5' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='_pos' type-id='95e97e5e' visibility='default'/>
	- </data-member>
	- </class-decl>
	- <typedef-decl name='__off_t' type-id='bd54fe1a' id='79989e9c'/>
	- <typedef-decl name='_IO_lock_t' type-id='48b5725f' id='bb4788fa'/>
	- <typedef-decl name='__off64_t' type-id='bd54fe1a' id='724e4de6'/>
	<pointer-type-def type-id='aa12d1ba' size-in-bits='64' id='822cd80b'/>
	+ <qualified-type-def type-id='822cd80b' restrict='yes' id='e75a27e9'/>
	<pointer-type-def type-id='ec1ed955' size-in-bits='64' id='dca988a5'/>
	+ <pointer-type-def type-id='a4036571' size-in-bits='64' id='570f8c59'/>
	<pointer-type-def type-id='bb4788fa' size-in-bits='64' id='cecf4ea7'/>
	<pointer-type-def type-id='010ae0b9' size-in-bits='64' id='e4c6fa61'/>
	+ <pointer-type-def type-id='79bd3751' size-in-bits='64' id='c65a1f29'/>
	+ <qualified-type-def type-id='80f4b756' restrict='yes' id='9d26089a'/>
	<pointer-type-def type-id='2367d595' size-in-bits='64' id='ed73b5ca'/>
	+ <class-decl name='_IO_codecvt' is-struct='yes' visibility='default' is-declaration-only='yes' id='a4036571'/>
	+ <class-decl name='_IO_marker' is-struct='yes' visibility='default' is-declaration-only='yes' id='010ae0b9'/>
	+ <class-decl name='_IO_wide_data' is-struct='yes' visibility='default' is-declaration-only='yes' id='79bd3751'/>
	<function-decl name='uu_dprintf_create' mangled-name='uu_dprintf_create' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_dprintf_create'>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='ceb5296f' name='severity'/>
	<parameter type-id='3502e3ff' name='flags'/>
	<return type-id='ed73b5ca'/>
	</function-decl>
	<function-decl name='uu_dprintf' mangled-name='uu_dprintf' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_dprintf'>
	<parameter type-id='ed73b5ca' name='D'/>
	<parameter type-id='ceb5296f' name='severity'/>
	<parameter type-id='80f4b756' name='format'/>
	<parameter is-variadic='yes'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='uu_dprintf_destroy' mangled-name='uu_dprintf_destroy' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_dprintf_destroy'>
	<parameter type-id='ed73b5ca' name='D'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='uu_dprintf_getname' mangled-name='uu_dprintf_getname' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_dprintf_getname'>
	<parameter type-id='ed73b5ca' name='D'/>
	<return type-id='80f4b756'/>
	</function-decl>
	- <function-decl name='__strdup' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='80f4b756'/>
	- <return type-id='26a90f95'/>
	- </function-decl>
	<function-decl name='dcgettext' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='80f4b756'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='95e97e5e'/>
	<return type-id='26a90f95'/>
	</function-decl>
	<function-decl name='fprintf' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='822cd80b'/>
	- <parameter type-id='80f4b756'/>
	+ <parameter type-id='e75a27e9'/>
	+ <parameter type-id='9d26089a'/>
	<parameter is-variadic='yes'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='vfprintf' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='822cd80b'/>
	- <parameter type-id='80f4b756'/>
	+ <parameter type-id='e75a27e9'/>
	+ <parameter type-id='9d26089a'/>
	<parameter type-id='b7f2d5e6'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	+ <function-decl name='strdup' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='80f4b756'/>
	+ <return type-id='26a90f95'/>
	+ </function-decl>
	+ </abi-instr>
	+ <abi-instr address-size='64' path='uu_ident.c' language='LANG_C99'>
	+ <function-decl name='strchr' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='95e97e5e'/>
	+ <return type-id='26a90f95'/>
	+ </function-decl>
	</abi-instr>
	- <abi-instr version='1.0' address-size='64' path='uu_list.c' language='LANG_C89'>
	+ <abi-instr address-size='64' path='uu_list.c' language='LANG_C99'>
	<array-type-def dimensions='1' type-id='e475ab95' size-in-bits='128' id='d0e9cdae'>
	- <subrange length='2' type-id='4c87fef4' id='52efc4ef'/>
	+ <subrange length='2' type-id='7359adad' id='52efc4ef'/>
	</array-type-def>
	- <class-decl name='uu_list_pool' size-in-bits='2112' is-struct='yes' visibility='default' id='55168cab'>
	+ <typedef-decl name='uu_list_pool_t' type-id='55168cab' id='38a2549d'/>
	+ <typedef-decl name='uu_list_t' type-id='1d04bdf0' id='82e88484'/>
	+ <class-decl name='uu_list_node' size-in-bits='128' is-struct='yes' visibility='default' id='f8f3cec5'>
	<data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='ulp_next' type-id='0941e04e' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='ulp_prev' type-id='0941e04e' visibility='default'/>
	+ <var-decl name='uln_opaque' type-id='d0e9cdae' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='ulp_name' type-id='59daf3ef' visibility='default'/>
	+ </class-decl>
	+ <typedef-decl name='uu_list_node_t' type-id='f8f3cec5' id='c4dc472f'/>
	+ <typedef-decl name='uu_list_walk_t' type-id='b80e3208' id='9fed32d2'/>
	+ <typedef-decl name='uu_list_index_t' type-id='e475ab95' id='f0dd35ff'/>
	+ <class-decl name='uu_list_node_impl' size-in-bits='128' is-struct='yes' visibility='default' id='700a795c'>
	+ <data-member access='public' layout-offset-in-bits='0'>
	+ <var-decl name='uln_next' type-id='5af1298a' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='640'>
	- <var-decl name='ulp_nodeoffset' type-id='b59d7dce' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='64'>
	+ <var-decl name='uln_prev' type-id='5af1298a' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='704'>
	- <var-decl name='ulp_objsize' type-id='b59d7dce' visibility='default'/>
	+ </class-decl>
	+ <typedef-decl name='uu_list_node_impl_t' type-id='700a795c' id='8e5864b0'/>
	+ <class-decl name='uu_list_walk' size-in-bits='320' is-struct='yes' visibility='default' id='b80e3208'>
	+ <data-member access='public' layout-offset-in-bits='0'>
	+ <var-decl name='ulw_next' type-id='4d848103' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='768'>
	- <var-decl name='ulp_cmp' type-id='d502b39f' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='64'>
	+ <var-decl name='ulw_prev' type-id='4d848103' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='832'>
	- <var-decl name='ulp_debug' type-id='b96825af' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='128'>
	+ <var-decl name='ulw_list' type-id='0c0b229b' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='840'>
	- <var-decl name='ulp_last_index' type-id='b96825af' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='192'>
	+ <var-decl name='ulw_dir' type-id='ee31ee44' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='896'>
	- <var-decl name='ulp_lock' type-id='7a6844eb' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='200'>
	+ <var-decl name='ulw_robust' type-id='b96825af' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='1216'>
	- <var-decl name='ulp_null_list' type-id='82e88484' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='256'>
	+ <var-decl name='ulw_next_result' type-id='a085247f' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='uu_list_pool_t' type-id='55168cab' id='38a2549d'/>
	<class-decl name='uu_list' size-in-bits='896' is-struct='yes' visibility='default' id='1d04bdf0'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='ul_next_enc' type-id='e475ab95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='ul_prev_enc' type-id='e475ab95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='ul_pool' type-id='0941e04e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	<var-decl name='ul_parent_enc' type-id='e475ab95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='256'>
	<var-decl name='ul_offset' type-id='b59d7dce' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='320'>
	<var-decl name='ul_numnodes' type-id='b59d7dce' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='384'>
	<var-decl name='ul_debug' type-id='b96825af' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='392'>
	<var-decl name='ul_sorted' type-id='b96825af' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='400'>
	<var-decl name='ul_index' type-id='b96825af' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='448'>
	<var-decl name='ul_null_node' type-id='8e5864b0' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='576'>
	<var-decl name='ul_null_walk' type-id='9fed32d2' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='uu_list_node_impl_t' type-id='700a795c' id='8e5864b0'/>
	- <class-decl name='uu_list_node_impl' size-in-bits='128' is-struct='yes' visibility='default' id='700a795c'>
	+ <class-decl name='uu_list_pool' size-in-bits='2112' is-struct='yes' visibility='default' id='55168cab'>
	<data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='uln_next' type-id='5af1298a' visibility='default'/>
	+ <var-decl name='ulp_next' type-id='0941e04e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='uln_prev' type-id='5af1298a' visibility='default'/>
	+ <var-decl name='ulp_prev' type-id='0941e04e' visibility='default'/>
	</data-member>
	- </class-decl>
	- <class-decl name='uu_list_walk' size-in-bits='320' is-struct='yes' visibility='default' id='b80e3208'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='ulw_next' type-id='4d848103' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='128'>
	+ <var-decl name='ulp_name' type-id='59daf3ef' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='ulw_prev' type-id='4d848103' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='640'>
	+ <var-decl name='ulp_nodeoffset' type-id='b59d7dce' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='ulw_list' type-id='0c0b229b' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='704'>
	+ <var-decl name='ulp_objsize' type-id='b59d7dce' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='192'>
	- <var-decl name='ulw_dir' type-id='ee31ee44' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='768'>
	+ <var-decl name='ulp_cmp' type-id='d502b39f' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='200'>
	- <var-decl name='ulw_robust' type-id='b96825af' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='832'>
	+ <var-decl name='ulp_debug' type-id='b96825af' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='256'>
	- <var-decl name='ulw_next_result' type-id='a085247f' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='840'>
	+ <var-decl name='ulp_last_index' type-id='b96825af' visibility='default'/>
	</data-member>
	- </class-decl>
	- <typedef-decl name='uu_list_walk_t' type-id='b80e3208' id='9fed32d2'/>
	- <typedef-decl name='uu_list_t' type-id='1d04bdf0' id='82e88484'/>
	- <typedef-decl name='uu_list_node_t' type-id='f8f3cec5' id='c4dc472f'/>
	- <class-decl name='uu_list_node' size-in-bits='128' is-struct='yes' visibility='default' id='f8f3cec5'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='uln_opaque' type-id='d0e9cdae' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='896'>
	+ <var-decl name='ulp_lock' type-id='7a6844eb' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='1216'>
	+ <var-decl name='ulp_null_list' type-id='82e88484' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='uu_list_index_t' type-id='e475ab95' id='f0dd35ff'/>
	<pointer-type-def type-id='f0dd35ff' size-in-bits='64' id='ecbc0046'/>
	<pointer-type-def type-id='700a795c' size-in-bits='64' id='5af1298a'/>
	<pointer-type-def type-id='8e5864b0' size-in-bits='64' id='a085247f'/>
	<pointer-type-def type-id='c4dc472f' size-in-bits='64' id='dbe143f4'/>
	<pointer-type-def type-id='38a2549d' size-in-bits='64' id='0941e04e'/>
	<pointer-type-def type-id='82e88484' size-in-bits='64' id='0c0b229b'/>
	<pointer-type-def type-id='9fed32d2' size-in-bits='64' id='4d848103'/>
	<function-decl name='uu_list_pool_create' mangled-name='uu_list_pool_create' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_list_pool_create'>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='b59d7dce' name='objsize'/>
	<parameter type-id='b59d7dce' name='nodeoffset'/>
	<parameter type-id='d502b39f' name='compare_func'/>
	<parameter type-id='8f92235e' name='flags'/>
	<return type-id='0941e04e'/>
	</function-decl>
	<function-decl name='uu_list_pool_destroy' mangled-name='uu_list_pool_destroy' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_list_pool_destroy'>
	<parameter type-id='0941e04e' name='pp'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='uu_list_node_init' mangled-name='uu_list_node_init' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_list_node_init'>
	<parameter type-id='eaa32e2f' name='base'/>
	<parameter type-id='dbe143f4' name='np_arg'/>
	<parameter type-id='0941e04e' name='pp'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='uu_list_node_fini' mangled-name='uu_list_node_fini' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_list_node_fini'>
	<parameter type-id='eaa32e2f' name='base'/>
	<parameter type-id='dbe143f4' name='np_arg'/>
	<parameter type-id='0941e04e' name='pp'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='uu_list_create' mangled-name='uu_list_create' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_list_create'>
	<parameter type-id='0941e04e' name='pp'/>
	<parameter type-id='eaa32e2f' name='parent'/>
	<parameter type-id='8f92235e' name='flags'/>
	<return type-id='0c0b229b'/>
	</function-decl>
	<function-decl name='uu_list_destroy' mangled-name='uu_list_destroy' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_list_destroy'>
	<parameter type-id='0c0b229b' name='lp'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='uu_list_insert' mangled-name='uu_list_insert' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_list_insert'>
	<parameter type-id='0c0b229b' name='lp'/>
	<parameter type-id='eaa32e2f' name='elem'/>
	<parameter type-id='f0dd35ff' name='idx'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='uu_list_find' mangled-name='uu_list_find' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_list_find'>
	<parameter type-id='0c0b229b' name='lp'/>
	<parameter type-id='eaa32e2f' name='elem'/>
	<parameter type-id='eaa32e2f' name='private'/>
	<parameter type-id='ecbc0046' name='out'/>
	<return type-id='eaa32e2f'/>
	</function-decl>
	<function-decl name='uu_list_nearest_next' mangled-name='uu_list_nearest_next' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_list_nearest_next'>
	<parameter type-id='0c0b229b' name='lp'/>
	<parameter type-id='f0dd35ff' name='idx'/>
	<return type-id='eaa32e2f'/>
	</function-decl>
	<function-decl name='uu_list_nearest_prev' mangled-name='uu_list_nearest_prev' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_list_nearest_prev'>
	<parameter type-id='0c0b229b' name='lp'/>
	<parameter type-id='f0dd35ff' name='idx'/>
	<return type-id='eaa32e2f'/>
	</function-decl>
	<function-decl name='uu_list_walk_start' mangled-name='uu_list_walk_start' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_list_walk_start'>
	<parameter type-id='0c0b229b' name='lp'/>
	<parameter type-id='8f92235e' name='flags'/>
	<return type-id='4d848103'/>
	</function-decl>
	<function-decl name='uu_list_walk_next' mangled-name='uu_list_walk_next' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_list_walk_next'>
	<parameter type-id='4d848103' name='wp'/>
	<return type-id='eaa32e2f'/>
	</function-decl>
	<function-decl name='uu_list_walk_end' mangled-name='uu_list_walk_end' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_list_walk_end'>
	<parameter type-id='4d848103' name='wp'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='uu_list_walk' mangled-name='uu_list_walk' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_list_walk'>
	<parameter type-id='0c0b229b' name='lp'/>
	<parameter type-id='30a42b6d' name='func'/>
	<parameter type-id='eaa32e2f' name='private'/>
	<parameter type-id='8f92235e' name='flags'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='uu_list_remove' mangled-name='uu_list_remove' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_list_remove'>
	<parameter type-id='0c0b229b' name='lp'/>
	<parameter type-id='eaa32e2f' name='elem'/>
	<return type-id='48b5725f'/>
	</function-decl>
	+ <function-decl name='uu_list_teardown' mangled-name='uu_list_teardown' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_list_teardown'>
	+ <parameter type-id='0c0b229b' name='lp'/>
	+ <parameter type-id='63e171df' name='cookie'/>
	+ <return type-id='eaa32e2f'/>
	+ </function-decl>
	<function-decl name='uu_list_insert_before' mangled-name='uu_list_insert_before' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_list_insert_before'>
	<parameter type-id='0c0b229b' name='lp'/>
	<parameter type-id='eaa32e2f' name='target'/>
	<parameter type-id='eaa32e2f' name='elem'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='uu_list_insert_after' mangled-name='uu_list_insert_after' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_list_insert_after'>
	<parameter type-id='0c0b229b' name='lp'/>
	<parameter type-id='eaa32e2f' name='target'/>
	<parameter type-id='eaa32e2f' name='elem'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='uu_list_numnodes' mangled-name='uu_list_numnodes' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_list_numnodes'>
	<parameter type-id='0c0b229b' name='lp'/>
	<return type-id='b59d7dce'/>
	</function-decl>
	<function-decl name='uu_list_first' mangled-name='uu_list_first' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_list_first'>
	<parameter type-id='0c0b229b' name='lp'/>
	<return type-id='eaa32e2f'/>
	</function-decl>
	- <function-decl name='uu_list_teardown' mangled-name='uu_list_teardown' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_list_teardown'>
	- <parameter type-id='0c0b229b' name='lp'/>
	- <parameter type-id='63e171df' name='cookie'/>
	- <return type-id='eaa32e2f'/>
	- </function-decl>
	<function-decl name='uu_list_last' mangled-name='uu_list_last' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_list_last'>
	<parameter type-id='0c0b229b' name='lp'/>
	<return type-id='eaa32e2f'/>
	</function-decl>
	<function-decl name='uu_list_next' mangled-name='uu_list_next' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_list_next'>
	<parameter type-id='0c0b229b' name='lp'/>
	<parameter type-id='eaa32e2f' name='elem'/>
	<return type-id='eaa32e2f'/>
	</function-decl>
	<function-decl name='uu_list_prev' mangled-name='uu_list_prev' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_list_prev'>
	<parameter type-id='0c0b229b' name='lp'/>
	<parameter type-id='eaa32e2f' name='elem'/>
	<return type-id='eaa32e2f'/>
	</function-decl>
	<function-decl name='uu_list_lockup' mangled-name='uu_list_lockup' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_list_lockup'>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='uu_list_release' mangled-name='uu_list_release' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_list_release'>
	<return type-id='48b5725f'/>
	</function-decl>
	</abi-instr>
	- <abi-instr version='1.0' address-size='64' path='uu_misc.c' language='LANG_C89'>
	- <typedef-decl name='pthread_key_t' type-id='f0981eeb' id='2de5383b'/>
	+ <abi-instr address-size='64' path='uu_misc.c' language='LANG_C99'>
	<typedef-decl name='pthread_t' type-id='7359adad' id='4051f5e7'/>
	+ <typedef-decl name='pthread_key_t' type-id='f0981eeb' id='2de5383b'/>
	<qualified-type-def type-id='8efea9e5' const='yes' id='3beb2af4'/>
	<pointer-type-def type-id='3beb2af4' size-in-bits='64' id='31347b7a'/>
	<pointer-type-def type-id='31347b7a' size-in-bits='64' id='c59e1ef0'/>
	<pointer-type-def type-id='95e97e5e' size-in-bits='64' id='7292109c'/>
	<pointer-type-def type-id='2de5383b' size-in-bits='64' id='ce04b822'/>
	<pointer-type-def type-id='ee076206' size-in-bits='64' id='953b12f8'/>
	<pointer-type-def type-id='c5c76c9c' size-in-bits='64' id='b7f9d8e6'/>
	<function-decl name='uu_error' mangled-name='uu_error' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_error'>
	<return type-id='8f92235e'/>
	</function-decl>
	<function-decl name='uu_strerror' mangled-name='uu_strerror' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_strerror'>
	<parameter type-id='8f92235e' name='code'/>
	<return type-id='80f4b756'/>
	</function-decl>
	<function-decl name='uu_dump' mangled-name='uu_dump' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_dump'>
	<parameter type-id='822cd80b' name='out'/>
	<parameter type-id='80f4b756' name='prefix'/>
	<parameter type-id='eaa32e2f' name='buf'/>
	<parameter type-id='b59d7dce' name='len'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='pthread_setspecific' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='2de5383b'/>
	- <parameter type-id='eaa32e2f'/>
	- <return type-id='95e97e5e'/>
	+ <function-decl name='__ctype_b_loc' visibility='default' binding='global' size-in-bits='64'>
	+ <return type-id='c59e1ef0'/>
	+ </function-decl>
	+ <function-decl name='__errno_location' visibility='default' binding='global' size-in-bits='64'>
	+ <return type-id='7292109c'/>
	+ </function-decl>
	+ <function-decl name='pthread_self' visibility='default' binding='global' size-in-bits='64'>
	+ <return type-id='4051f5e7'/>
	</function-decl>
	<function-decl name='pthread_key_create' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='ce04b822'/>
	<parameter type-id='b7f9d8e6'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='pthread_getspecific' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='2de5383b'/>
	<return type-id='eaa32e2f'/>
	</function-decl>
	- <function-decl name='__errno_location' visibility='default' binding='global' size-in-bits='64'>
	- <return type-id='7292109c'/>
	- </function-decl>
	- <function-decl name='pthread_self' visibility='default' binding='global' size-in-bits='64'>
	- <return type-id='4051f5e7'/>
	- </function-decl>
	- <function-decl name='pause' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='pthread_setspecific' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='2de5383b'/>
	+ <parameter type-id='eaa32e2f'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='abort' visibility='default' binding='global' size-in-bits='64'>
	- <return type-id='48b5725f'/>
	- </function-decl>
	<function-decl name='pthread_atfork' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='953b12f8'/>
	<parameter type-id='953b12f8'/>
	<parameter type-id='953b12f8'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='__ctype_b_loc' visibility='default' binding='global' size-in-bits='64'>
	- <return type-id='c59e1ef0'/>
	+ <function-decl name='abort' visibility='default' binding='global' size-in-bits='64'>
	+ <return type-id='48b5725f'/>
	+ </function-decl>
	+ <function-decl name='pause' visibility='default' binding='global' size-in-bits='64'>
	+ <return type-id='95e97e5e'/>
	</function-decl>
	<function-type size-in-bits='64' id='ee076206'>
	<return type-id='48b5725f'/>
	</function-type>
	<function-type size-in-bits='64' id='c5c76c9c'>
	<parameter type-id='eaa32e2f'/>
	<return type-id='48b5725f'/>
	</function-type>
	</abi-instr>
	- <abi-instr version='1.0' address-size='64' path='uu_open.c' language='LANG_C89'>
	- <typedef-decl name='clockid_t' type-id='08f9a87a' id='a1c3b834'/>
	+ <abi-instr address-size='64' path='uu_open.c' language='LANG_C99'>
	+ <typedef-decl name='__time_t' type-id='bd54fe1a' id='65eda9c0'/>
	<typedef-decl name='__clockid_t' type-id='95e97e5e' id='08f9a87a'/>
	+ <typedef-decl name='__syscall_slong_t' type-id='bd54fe1a' id='03085adc'/>
	+ <typedef-decl name='clockid_t' type-id='08f9a87a' id='a1c3b834'/>
	<class-decl name='timespec' size-in-bits='128' is-struct='yes' visibility='default' id='a9c79a1f'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='tv_sec' type-id='65eda9c0' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='tv_nsec' type-id='03085adc' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='__time_t' type-id='bd54fe1a' id='65eda9c0'/>
	- <typedef-decl name='__syscall_slong_t' type-id='bd54fe1a' id='03085adc'/>
	<pointer-type-def type-id='a9c79a1f' size-in-bits='64' id='3d83ba87'/>
	<function-decl name='uu_open_tmp' mangled-name='uu_open_tmp' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_open_tmp'>
	<parameter type-id='80f4b756' name='dir'/>
	<parameter type-id='3502e3ff' name='uflags'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='clock_gettime' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='a1c3b834'/>
	- <parameter type-id='3d83ba87'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	<function-decl name='snprintf' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='26a90f95'/>
	<parameter type-id='b59d7dce'/>
	<parameter type-id='80f4b756'/>
	<parameter is-variadic='yes'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	+ <function-decl name='clock_gettime' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='a1c3b834'/>
	+ <parameter type-id='3d83ba87'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	<function-decl name='unlink' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='80f4b756'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	</abi-instr>
	- <abi-instr version='1.0' address-size='64' path='uu_pname.c' language='LANG_C89'>
	+ <abi-instr address-size='64' path='uu_pname.c' language='LANG_C99'>
	+ <function-decl name='getexecname' mangled-name='getexecname' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='getexecname'>
	+ <return type-id='80f4b756'/>
	+ </function-decl>
	+ <var-decl name='uu_exit_ok_value' type-id='95e97e5e' mangled-name='uu_exit_ok_value' visibility='default' elf-symbol-id='uu_exit_ok_value'/>
	+ <var-decl name='uu_exit_fatal_value' type-id='95e97e5e' mangled-name='uu_exit_fatal_value' visibility='default' elf-symbol-id='uu_exit_fatal_value'/>
	+ <var-decl name='uu_exit_usage_value' type-id='95e97e5e' mangled-name='uu_exit_usage_value' visibility='default' elf-symbol-id='uu_exit_usage_value'/>
	<function-decl name='uu_exit_ok' mangled-name='uu_exit_ok' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_exit_ok'>
	<return type-id='7292109c'/>
	</function-decl>
	<function-decl name='uu_exit_fatal' mangled-name='uu_exit_fatal' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_exit_fatal'>
	<return type-id='7292109c'/>
	</function-decl>
	<function-decl name='uu_exit_usage' mangled-name='uu_exit_usage' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_exit_usage'>
	<return type-id='7292109c'/>
	</function-decl>
	<function-decl name='uu_alt_exit' mangled-name='uu_alt_exit' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_alt_exit'>
	<parameter type-id='95e97e5e' name='profile'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='uu_vwarn' mangled-name='uu_vwarn' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_vwarn'>
	<parameter type-id='80f4b756' name='format'/>
	<parameter type-id='b7f2d5e6' name='alist'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='uu_warn' mangled-name='uu_warn' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_warn'>
	<parameter type-id='80f4b756' name='format'/>
	<parameter is-variadic='yes'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='uu_vdie' mangled-name='uu_vdie' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_vdie'>
	<parameter type-id='80f4b756' name='format'/>
	<parameter type-id='b7f2d5e6' name='alist'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='uu_die' mangled-name='uu_die' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_die'>
	<parameter type-id='80f4b756' name='format'/>
	<parameter is-variadic='yes'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='uu_vxdie' mangled-name='uu_vxdie' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_vxdie'>
	<parameter type-id='95e97e5e' name='status'/>
	<parameter type-id='80f4b756' name='format'/>
	<parameter type-id='b7f2d5e6' name='alist'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='uu_xdie' mangled-name='uu_xdie' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_xdie'>
	<parameter type-id='95e97e5e' name='status'/>
	<parameter type-id='80f4b756' name='format'/>
	<parameter is-variadic='yes'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='uu_setpname' mangled-name='uu_setpname' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_setpname'>
	<parameter type-id='26a90f95' name='arg0'/>
	<return type-id='80f4b756'/>
	</function-decl>
	<function-decl name='uu_getpname' mangled-name='uu_getpname' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_getpname'>
	<return type-id='80f4b756'/>
	</function-decl>
	- <var-decl name='uu_exit_ok_value' type-id='95e97e5e' mangled-name='uu_exit_ok_value' visibility='default' elf-symbol-id='uu_exit_ok_value'/>
	- <var-decl name='uu_exit_fatal_value' type-id='95e97e5e' mangled-name='uu_exit_fatal_value' visibility='default' elf-symbol-id='uu_exit_fatal_value'/>
	- <var-decl name='uu_exit_usage_value' type-id='95e97e5e' mangled-name='uu_exit_usage_value' visibility='default' elf-symbol-id='uu_exit_usage_value'/>
	- <function-decl name='strerror' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='exit' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='95e97e5e'/>
	- <return type-id='26a90f95'/>
	+ <return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='strrchr' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='80f4b756'/>
	<parameter type-id='95e97e5e'/>
	<return type-id='26a90f95'/>
	</function-decl>
	- <function-decl name='exit' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='strerror' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='95e97e5e'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	- <function-decl name='getexecname' mangled-name='getexecname' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='getexecname'>
	- <return type-id='80f4b756'/>
	+ <return type-id='26a90f95'/>
	</function-decl>
	</abi-instr>
	- <abi-instr version='1.0' address-size='64' path='uu_string.c' language='LANG_C89'>
	- <typedef-decl name='boolean_t' type-id='08f5ca17' id='c19b74c3'/>
	- <enum-decl name='__anonymous_enum__' is-anonymous='yes' id='08f5ca17'>
	+ <abi-instr address-size='64' path='uu_string.c' language='LANG_C99'>
	+ <enum-decl name='boolean_t' naming-typedef-id='c19b74c3' id='f58c8277'>
	<underlying-type type-id='9cac1fee'/>
	<enumerator name='B_FALSE' value='0'/>
	<enumerator name='B_TRUE' value='1'/>
	</enum-decl>
	+ <typedef-decl name='boolean_t' type-id='f58c8277' id='c19b74c3'/>
	<function-decl name='uu_streq' mangled-name='uu_streq' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_streq'>
	<parameter type-id='80f4b756' name='a'/>
	<parameter type-id='80f4b756' name='b'/>
	<return type-id='c19b74c3'/>
	</function-decl>
	<function-decl name='uu_strcaseeq' mangled-name='uu_strcaseeq' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_strcaseeq'>
	<parameter type-id='80f4b756' name='a'/>
	<parameter type-id='80f4b756' name='b'/>
	<return type-id='c19b74c3'/>
	</function-decl>
	<function-decl name='uu_strbw' mangled-name='uu_strbw' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='uu_strbw'>
	<parameter type-id='80f4b756' name='a'/>
	<parameter type-id='80f4b756' name='b'/>
	<return type-id='c19b74c3'/>
	</function-decl>
	- <function-decl name='strcasecmp' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='strcmp' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='80f4b756'/>
	<parameter type-id='80f4b756'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='strncmp' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='80f4b756'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='b59d7dce'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	+ <function-decl name='strcasecmp' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='80f4b756'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	</abi-instr>
	</abi-corpus>
	diff --git a/sys/contrib/openzfs/lib/libzfs/libzfs.abi b/sys/contrib/openzfs/lib/libzfs/libzfs.abi
	index 2af0bd6f6956..82f8b7dc87f8 100644
	--- a/sys/contrib/openzfs/lib/libzfs/libzfs.abi
	+++ b/sys/contrib/openzfs/lib/libzfs/libzfs.abi
	@@ -1,7975 +1,7554 @@
	-<abi-corpus architecture='elf-amd-x86_64' soname='libzfs.so.4'>
	+<abi-corpus version='2.0' architecture='elf-amd-x86_64' soname='libzfs.so.4'>
	<elf-needed>
	<dependency name='libzfs_core.so.3'/>
	<dependency name='libuuid.so.1'/>
	- <dependency name='librt.so.1'/>
	<dependency name='libblkid.so.1'/>
	<dependency name='libudev.so.1'/>
	<dependency name='libnvpair.so.3'/>
	+ <dependency name='libtirpc.so.3'/>
	<dependency name='libuutil.so.3'/>
	<dependency name='libm.so.6'/>
	- <dependency name='libcrypto.so.10'/>
	+ <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='_fini' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	- <elf-symbol name='_init' 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_disable_datasets' type='func-type' binding='global-binding' visibility='default-visibility' alias='zpool_unmount_datasets' 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_unmount_datasets' type='func-type' binding='weak-binding' visibility='default-visibility' 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='libshare.c' language='LANG_C89'>
	- <typedef-decl name='sa_fstype_t' type-id='b329094d' id='639af739'/>
	- <class-decl name='sa_fstype' size-in-bits='256' is-struct='yes' visibility='default' id='b329094d'>
	+ <abi-instr address-size='64' path='libshare.c' language='LANG_C99'>
	+ <class-decl name='sa_share_fsinfo' size-in-bits='64' is-struct='yes' visibility='default' id='412a8a55'>
	<data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='next' type-id='3a81ee0d' visibility='default'/>
	+ <var-decl name='shareopts' type-id='26a90f95' visibility='default'/>
	+ </data-member>
	+ </class-decl>
	+ <typedef-decl name='sa_share_fsinfo_t' type-id='412a8a55' id='24463d51'/>
	+ <class-decl name='sa_share_impl' size-in-bits='192' is-struct='yes' visibility='default' id='72b09bf8'>
	+ <data-member access='public' layout-offset-in-bits='0'>
	+ <var-decl name='sa_mountpoint' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='name' type-id='80f4b756' visibility='default'/>
	+ <var-decl name='sa_zfsname' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='ops' type-id='4f0de78a' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='192'>
	- <var-decl name='fsinfo_index' type-id='95e97e5e' visibility='default'/>
	+ <var-decl name='sa_fsinfo' type-id='17934354' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='sa_share_ops_t' type-id='9990a42a' id='cfdd2674'/>
	+ <typedef-decl name='sa_share_impl_t' type-id='2722c1de' id='a48b47d0'/>
	<class-decl name='sa_share_ops' size-in-bits='448' is-struct='yes' visibility='default' id='9990a42a'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='enable_share' type-id='fa1f29ce' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='disable_share' type-id='fa1f29ce' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='is_shared' type-id='f337456d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	<var-decl name='validate_shareopts' type-id='70487b28' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='256'>
	<var-decl name='update_shareopts' type-id='8c9ca98d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='320'>
	<var-decl name='clear_shareopts' type-id='20e6b301' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='384'>
	<var-decl name='commit_shares' type-id='1db260e5' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='sa_share_impl_t' type-id='2722c1de' id='a48b47d0'/>
	- <class-decl name='sa_share_impl' size-in-bits='192' is-struct='yes' visibility='default' id='72b09bf8'>
	+ <typedef-decl name='sa_share_ops_t' type-id='9990a42a' id='cfdd2674'/>
	+ <class-decl name='sa_fstype' size-in-bits='256' is-struct='yes' visibility='default' id='b329094d'>
	<data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='sa_mountpoint' type-id='26a90f95' visibility='default'/>
	+ <var-decl name='next' type-id='3a81ee0d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='sa_zfsname' type-id='26a90f95' visibility='default'/>
	+ <var-decl name='name' type-id='80f4b756' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='sa_fsinfo' type-id='17934354' visibility='default'/>
	+ <var-decl name='ops' type-id='4f0de78a' visibility='default'/>
	</data-member>
	- </class-decl>
	- <typedef-decl name='sa_share_fsinfo_t' type-id='412a8a55' id='24463d51'/>
	- <class-decl name='sa_share_fsinfo' size-in-bits='64' is-struct='yes' visibility='default' id='412a8a55'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='shareopts' type-id='26a90f95' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='192'>
	+ <var-decl name='fsinfo_index' type-id='95e97e5e' visibility='default'/>
	</data-member>
	</class-decl>
	+ <typedef-decl name='sa_fstype_t' type-id='b329094d' id='639af739'/>
	<qualified-type-def type-id='cfdd2674' const='yes' id='3903d8a4'/>
	<pointer-type-def type-id='3903d8a4' size-in-bits='64' id='4f0de78a'/>
	<pointer-type-def type-id='276427e1' size-in-bits='64' id='1db260e5'/>
	<pointer-type-def type-id='5113b296' size-in-bits='64' id='70487b28'/>
	<pointer-type-def type-id='c13578bc' size-in-bits='64' id='fa1f29ce'/>
	<pointer-type-def type-id='4d896449' size-in-bits='64' id='8c9ca98d'/>
	<pointer-type-def type-id='b329094d' size-in-bits='64' id='3a81ee0d'/>
	<pointer-type-def type-id='639af739' size-in-bits='64' id='0dd0309c'/>
	<pointer-type-def type-id='24463d51' size-in-bits='64' id='17934354'/>
	<pointer-type-def type-id='72b09bf8' size-in-bits='64' id='2722c1de'/>
	<pointer-type-def type-id='86373eb1' size-in-bits='64' id='f337456d'/>
	<pointer-type-def type-id='6b19040d' size-in-bits='64' id='20e6b301'/>
	<function-decl name='register_fstype' mangled-name='register_fstype' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='register_fstype'>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='4f0de78a' name='ops'/>
	<return type-id='0dd0309c'/>
	</function-decl>
	<function-decl name='libshare_nfs_init' mangled-name='libshare_nfs_init' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libshare_nfs_init'>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='libshare_smb_init' mangled-name='libshare_smb_init' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libshare_smb_init'>
	<return type-id='48b5725f'/>
	</function-decl>
	- <pointer-type-def type-id='a84c031d' size-in-bits='64' id='26a90f95'/>
	- <pointer-type-def type-id='9b45d938' size-in-bits='64' id='80f4b756'/>
	<function-type size-in-bits='64' id='276427e1'>
	<return type-id='95e97e5e'/>
	</function-type>
	<function-type size-in-bits='64' id='5113b296'>
	<parameter type-id='80f4b756'/>
	<return type-id='95e97e5e'/>
	</function-type>
	<function-type size-in-bits='64' id='c13578bc'>
	<parameter type-id='a48b47d0'/>
	<return type-id='95e97e5e'/>
	</function-type>
	<function-type size-in-bits='64' id='4d896449'>
	<parameter type-id='a48b47d0'/>
	<parameter type-id='80f4b756'/>
	<return type-id='95e97e5e'/>
	</function-type>
	<function-type size-in-bits='64' id='86373eb1'>
	<parameter type-id='a48b47d0'/>
	<return type-id='c19b74c3'/>
	</function-type>
	<function-type size-in-bits='64' id='6b19040d'>
	<parameter type-id='a48b47d0'/>
	<return type-id='48b5725f'/>
	</function-type>
	- <type-decl name='int' size-in-bits='32' id='95e97e5e'/>
	- <type-decl name='void' id='48b5725f'/>
	- <type-decl name='char' size-in-bits='8' id='a84c031d'/>
	- <qualified-type-def type-id='a84c031d' const='yes' id='9b45d938'/>
	- <typedef-decl name='boolean_t' type-id='40ed39d2' id='c19b74c3'/>
	- <enum-decl name='__anonymous_enum__1' is-anonymous='yes' id='40ed39d2'>
	- <underlying-type type-id='9cac1fee'/>
	- <enumerator name='B_FALSE' value='0'/>
	- <enumerator name='B_TRUE' value='1'/>
	- </enum-decl>
	</abi-instr>
	- <abi-instr version='1.0' address-size='64' path='os/linux/nfs.c' language='LANG_C89'>
	- <function-decl name='mkdir' visibility='default' binding='global' size-in-bits='64'>
	+ <abi-instr address-size='64' path='os/linux/nfs.c' language='LANG_C99'>
	+ <function-decl name='rename' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='80f4b756'/>
	<parameter type-id='80f4b756'/>
	- <parameter type-id='e1c52942'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='fputs' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='822cd80b'/>
	+ <parameter type-id='9d26089a'/>
	+ <parameter type-id='e75a27e9'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='flock' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='95e97e5e'/>
	<parameter type-id='95e97e5e'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='unlink' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='mkdir' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='80f4b756'/>
	+ <parameter type-id='e1c52942'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='rename' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='80f4b756'/>
	+ <function-decl name='unlink' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='80f4b756'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <pointer-type-def type-id='aa12d1ba' size-in-bits='64' id='822cd80b'/>
	- <typedef-decl name='__mode_t' type-id='f0981eeb' id='e1c52942'/>
	- <typedef-decl name='FILE' type-id='ec1ed955' id='aa12d1ba'/>
	- <type-decl name='unsigned int' size-in-bits='32' id='f0981eeb'/>
	- <class-decl name='_IO_FILE' size-in-bits='1728' is-struct='yes' visibility='default' id='ec1ed955'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='_flags' type-id='95e97e5e' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='_IO_read_ptr' type-id='26a90f95' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='_IO_read_end' type-id='26a90f95' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='192'>
	- <var-decl name='_IO_read_base' type-id='26a90f95' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='256'>
	- <var-decl name='_IO_write_base' type-id='26a90f95' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='320'>
	- <var-decl name='_IO_write_ptr' type-id='26a90f95' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='384'>
	- <var-decl name='_IO_write_end' type-id='26a90f95' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='448'>
	- <var-decl name='_IO_buf_base' type-id='26a90f95' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='512'>
	- <var-decl name='_IO_buf_end' type-id='26a90f95' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='576'>
	- <var-decl name='_IO_save_base' type-id='26a90f95' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='640'>
	- <var-decl name='_IO_backup_base' type-id='26a90f95' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='704'>
	- <var-decl name='_IO_save_end' type-id='26a90f95' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='768'>
	- <var-decl name='_markers' type-id='e4c6fa61' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='832'>
	- <var-decl name='_chain' type-id='dca988a5' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='896'>
	- <var-decl name='_fileno' type-id='95e97e5e' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='928'>
	- <var-decl name='_flags2' type-id='95e97e5e' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='960'>
	- <var-decl name='_old_offset' type-id='79989e9c' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='1024'>
	- <var-decl name='_cur_column' type-id='8efea9e5' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='1040'>
	- <var-decl name='_vtable_offset' type-id='28577a57' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='1048'>
	- <var-decl name='_shortbuf' type-id='89feb1ec' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='1088'>
	- <var-decl name='_lock' type-id='cecf4ea7' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='1152'>
	- <var-decl name='_offset' type-id='724e4de6' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='1216'>
	- <var-decl name='__pad1' type-id='eaa32e2f' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='1280'>
	- <var-decl name='__pad2' type-id='eaa32e2f' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='1344'>
	- <var-decl name='__pad3' type-id='eaa32e2f' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='1408'>
	- <var-decl name='__pad4' type-id='eaa32e2f' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='1472'>
	- <var-decl name='__pad5' type-id='b59d7dce' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='1536'>
	- <var-decl name='_mode' type-id='95e97e5e' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='1568'>
	- <var-decl name='_unused2' type-id='664ac0b7' visibility='default'/>
	- </data-member>
	- </class-decl>
	- <pointer-type-def type-id='ec1ed955' size-in-bits='64' id='dca988a5'/>
	- <pointer-type-def type-id='bb4788fa' size-in-bits='64' id='cecf4ea7'/>
	- <pointer-type-def type-id='010ae0b9' size-in-bits='64' id='e4c6fa61'/>
	- <array-type-def dimensions='1' type-id='a84c031d' size-in-bits='8' id='89feb1ec'>
	- <subrange length='1' type-id='4c87fef4' id='52f813b4'/>
	- </array-type-def>
	- <array-type-def dimensions='1' type-id='a84c031d' size-in-bits='160' id='664ac0b7'>
	- <subrange length='20' type-id='4c87fef4' id='fdca39cf'/>
	- </array-type-def>
	- <type-decl name='signed char' size-in-bits='8' id='28577a57'/>
	- <typedef-decl name='__off64_t' type-id='bd54fe1a' id='724e4de6'/>
	- <typedef-decl name='__off_t' type-id='bd54fe1a' id='79989e9c'/>
	- <typedef-decl name='size_t' type-id='7359adad' id='b59d7dce'/>
	- <type-decl name='unsigned short int' size-in-bits='16' id='8efea9e5'/>
	- <pointer-type-def type-id='48b5725f' size-in-bits='64' id='eaa32e2f'/>
	- <class-decl name='_IO_marker' size-in-bits='192' is-struct='yes' visibility='default' id='010ae0b9'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='_next' type-id='e4c6fa61' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='_sbuf' type-id='dca988a5' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='_pos' type-id='95e97e5e' visibility='default'/>
	- </data-member>
	- </class-decl>
	- <type-decl name='long int' size-in-bits='64' id='bd54fe1a'/>
	- <type-decl name='sizetype' size-in-bits='64' id='4c87fef4'/>
	- <typedef-decl name='_IO_lock_t' type-id='48b5725f' id='bb4788fa'/>
	- <type-decl name='unsigned long int' size-in-bits='64' id='7359adad'/>
	</abi-instr>
	- <abi-instr version='1.0' address-size='64' path='os/linux/smb.c' language='LANG_C89'>
	+ <abi-instr address-size='64' path='os/linux/smb.c' language='LANG_C99'>
	<array-type-def dimensions='1' type-id='a84c031d' size-in-bits='2040' id='11641789'>
	- <subrange length='255' type-id='4c87fef4' id='36e7f891'/>
	+ <subrange length='255' type-id='7359adad' id='36e7f891'/>
	</array-type-def>
	- <typedef-decl name='smb_share_t' type-id='a75bc907' id='2d05afd9'/>
	<class-decl name='smb_share_s' size-in-bits='36992' is-struct='yes' visibility='default' id='a75bc907'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='name' type-id='11641789' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='2040'>
	<var-decl name='path' type-id='d16c6df4' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='34808'>
	<var-decl name='comment' type-id='11641789' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='36864'>
	<var-decl name='guest_ok' type-id='c19b74c3' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='36928'>
	<var-decl name='next' type-id='05ed1c5f' visibility='default'/>
	</data-member>
	</class-decl>
	+ <typedef-decl name='smb_share_t' type-id='a75bc907' id='2d05afd9'/>
	<class-decl name='dirent' size-in-bits='2240' is-struct='yes' visibility='default' id='611586a1'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='d_ino' type-id='71288a47' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='d_off' type-id='724e4de6' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='d_reclen' type-id='8efea9e5' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='144'>
	<var-decl name='d_type' type-id='002ac4a6' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='152'>
	<var-decl name='d_name' type-id='d1617432' visibility='default'/>
	</data-member>
	</class-decl>
	<pointer-type-def type-id='611586a1' size-in-bits='64' id='2e243169'/>
	<pointer-type-def type-id='a75bc907' size-in-bits='64' id='05ed1c5f'/>
	<pointer-type-def type-id='2d05afd9' size-in-bits='64' id='a3e5c654'/>
	<var-decl name='smb_shares' type-id='a3e5c654' mangled-name='smb_shares' visibility='default' elf-symbol-id='smb_shares'/>
	<function-decl name='opendir' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='80f4b756'/>
	<return type-id='f09217ba'/>
	</function-decl>
	<function-decl name='fgets' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='26a90f95'/>
	+ <parameter type-id='266fe297'/>
	<parameter type-id='95e97e5e'/>
	- <parameter type-id='822cd80b'/>
	+ <parameter type-id='e75a27e9'/>
	<return type-id='26a90f95'/>
	</function-decl>
	- <pointer-type-def type-id='54a5d683' size-in-bits='64' id='f09217ba'/>
	- <array-type-def dimensions='1' type-id='a84c031d' size-in-bits='2048' id='d1617432'>
	- <subrange length='256' type-id='4c87fef4' id='36e5b9fa'/>
	- </array-type-def>
	- <array-type-def dimensions='1' type-id='a84c031d' size-in-bits='32768' id='d16c6df4'>
	- <subrange length='4096' type-id='4c87fef4' id='bc1b5ddc'/>
	- </array-type-def>
	- <typedef-decl name='__ino64_t' type-id='7359adad' id='71288a47'/>
	- <type-decl name='unsigned char' size-in-bits='8' id='002ac4a6'/>
	- <typedef-decl name='DIR' type-id='20cd73f2' id='54a5d683'/>
	- <class-decl name='__dirstream' is-struct='yes' visibility='default' is-declaration-only='yes' id='20cd73f2'/>
	+ <type-decl name='unsigned long int' size-in-bits='64' id='7359adad'/>
	+ <type-decl name='unsigned short int' size-in-bits='16' id='8efea9e5'/>
	</abi-instr>
	- <abi-instr version='1.0' address-size='64' path='../../module/icp/algs/sha2/sha2.c' language='LANG_C89'>
	+ <abi-instr address-size='64' path='../../module/icp/algs/sha2/sha2.c' language='LANG_C99'>
	<array-type-def dimensions='1' type-id='8f92235e' size-in-bits='64' id='337c1cdd'>
	- <subrange length='2' type-id='4c87fef4' id='52efc4ef'/>
	+ <subrange length='2' type-id='7359adad' id='52efc4ef'/>
	</array-type-def>
	<array-type-def dimensions='1' type-id='8f92235e' size-in-bits='1024' id='388e96b8'>
	- <subrange length='32' type-id='4c87fef4' id='ae5bde82'/>
	+ <subrange length='32' type-id='7359adad' id='ae5bde82'/>
	</array-type-def>
	<array-type-def dimensions='1' type-id='8f92235e' size-in-bits='256' id='2f8b211b'>
	- <subrange length='8' type-id='4c87fef4' id='56e0c0b1'/>
	+ <subrange length='8' type-id='7359adad' id='56e0c0b1'/>
	</array-type-def>
	<array-type-def dimensions='1' type-id='9c313c2d' size-in-bits='1024' id='b316cf0d'>
	- <subrange length='16' type-id='4c87fef4' id='848d0938'/>
	+ <subrange length='16' type-id='7359adad' id='848d0938'/>
	</array-type-def>
	<array-type-def dimensions='1' type-id='9c313c2d' size-in-bits='512' id='c5d13f42'>
	- <subrange length='8' type-id='4c87fef4' id='56e0c0b1'/>
	+ <subrange length='8' type-id='7359adad' id='56e0c0b1'/>
	</array-type-def>
	<array-type-def dimensions='1' type-id='b96825af' size-in-bits='1024' id='c768f32d'>
	- <subrange length='128' type-id='4c87fef4' id='1eb1687a'/>
	+ <subrange length='128' type-id='7359adad' id='1eb1687a'/>
	</array-type-def>
	- <typedef-decl name='SHA2_CTX' type-id='a26d6168' id='2aec903e'/>
	- <class-decl name='__anonymous_struct__' size-in-bits='1728' is-struct='yes' is-anonymous='yes' naming-typedef-id='2aec903e' visibility='default' id='a26d6168'>
	+ <class-decl name='SHA2_CTX' size-in-bits='1728' is-struct='yes' naming-typedef-id='2aec903e' visibility='default' id='51cc0913'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='algotype' type-id='8f92235e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='state' type-id='b443b68c' visibility='default'/>
	+ <var-decl name='state' type-id='ac5ab595' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='576'>
	- <var-decl name='count' type-id='d35546b8' visibility='default'/>
	+ <var-decl name='count' type-id='ac5ab596' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='704'>
	- <var-decl name='buf_un' type-id='3fcc284a' visibility='default'/>
	+ <var-decl name='buf_un' type-id='ac5ab597' visibility='default'/>
	</data-member>
	</class-decl>
	- <union-decl name='__anonymous_union__' size-in-bits='512' is-anonymous='yes' visibility='default' id='b443b68c'>
	- <data-member access='private'>
	+ <union-decl name='__anonymous_union__' size-in-bits='512' is-anonymous='yes' visibility='default' id='ac5ab595'>
	+ <data-member access='public'>
	<var-decl name='s32' type-id='2f8b211b' visibility='default'/>
	</data-member>
	- <data-member access='private'>
	+ <data-member access='public'>
	<var-decl name='s64' type-id='c5d13f42' visibility='default'/>
	</data-member>
	</union-decl>
	- <union-decl name='__anonymous_union__1' size-in-bits='128' is-anonymous='yes' visibility='default' id='d35546b8'>
	- <data-member access='private'>
	+ <union-decl name='__anonymous_union__1' size-in-bits='128' is-anonymous='yes' visibility='default' id='ac5ab596'>
	+ <data-member access='public'>
	<var-decl name='c32' type-id='337c1cdd' visibility='default'/>
	</data-member>
	- <data-member access='private'>
	+ <data-member access='public'>
	<var-decl name='c64' type-id='c1c22e6c' visibility='default'/>
	</data-member>
	</union-decl>
	- <union-decl name='__anonymous_union__2' size-in-bits='1024' is-anonymous='yes' visibility='default' id='3fcc284a'>
	- <data-member access='private'>
	+ <union-decl name='__anonymous_union__2' size-in-bits='1024' is-anonymous='yes' visibility='default' id='ac5ab597'>
	+ <data-member access='public'>
	<var-decl name='buf8' type-id='c768f32d' visibility='default'/>
	</data-member>
	- <data-member access='private'>
	+ <data-member access='public'>
	<var-decl name='buf32' type-id='388e96b8' visibility='default'/>
	</data-member>
	- <data-member access='private'>
	+ <data-member access='public'>
	<var-decl name='buf64' type-id='b316cf0d' visibility='default'/>
	</data-member>
	</union-decl>
	+ <typedef-decl name='SHA2_CTX' type-id='51cc0913' id='2aec903e'/>
	<typedef-decl name='SHA256_CTX' type-id='2aec903e' id='1ef7fe01'/>
	<typedef-decl name='SHA384_CTX' type-id='2aec903e' id='139bfea5'/>
	<typedef-decl name='SHA512_CTX' type-id='2aec903e' id='33c643d0'/>
	<pointer-type-def type-id='1ef7fe01' size-in-bits='64' id='aacf5386'/>
	<pointer-type-def type-id='2aec903e' size-in-bits='64' id='5d626b03'/>
	<pointer-type-def type-id='139bfea5' size-in-bits='64' id='074c43fa'/>
	<pointer-type-def type-id='33c643d0' size-in-bits='64' id='ceba8189'/>
	+ <function-decl name='htonl' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='8f92235e'/>
	+ <return type-id='8f92235e'/>
	+ </function-decl>
	<function-decl name='SHA2Init' mangled-name='SHA2Init' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='SHA2Init'>
	<parameter type-id='9c313c2d' name='mech'/>
	<parameter type-id='5d626b03' name='ctx'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='SHA256Init' mangled-name='SHA256Init' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='SHA256Init'>
	<parameter type-id='aacf5386' name='ctx'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='SHA384Init' mangled-name='SHA384Init' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='SHA384Init'>
	<parameter type-id='074c43fa' name='ctx'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='SHA512Init' mangled-name='SHA512Init' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='SHA512Init'>
	<parameter type-id='ceba8189' name='ctx'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='SHA2Update' mangled-name='SHA2Update' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='SHA2Update'>
	<parameter type-id='5d626b03' name='ctx'/>
	<parameter type-id='eaa32e2f' name='inptr'/>
	<parameter type-id='b59d7dce' name='input_len'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='SHA2Final' mangled-name='SHA2Final' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='SHA2Final'>
	<parameter type-id='eaa32e2f' name='digest'/>
	<parameter type-id='5d626b03' name='ctx'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='htonl' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='8f92235e'/>
	- <return type-id='8f92235e'/>
	- </function-decl>
	- <typedef-decl name='uint32_t' type-id='f0981eeb' id='8f92235e'/>
	- <typedef-decl name='uint64_t' type-id='7359adad' id='9c313c2d'/>
	- <typedef-decl name='uint8_t' type-id='002ac4a6' id='b96825af'/>
	- <array-type-def dimensions='1' type-id='9c313c2d' size-in-bits='128' id='c1c22e6c'>
	- <subrange length='2' type-id='4c87fef4' id='52efc4ef'/>
	- </array-type-def>
	</abi-instr>
	- <abi-instr version='1.0' address-size='64' path='../../module/zcommon/cityhash.c' language='LANG_C89'>
	+ <abi-instr address-size='64' path='../../module/zcommon/cityhash.c' language='LANG_C99'>
	<function-decl name='cityhash4' mangled-name='cityhash4' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='cityhash4'>
	<parameter type-id='9c313c2d' name='w1'/>
	<parameter type-id='9c313c2d' name='w2'/>
	<parameter type-id='9c313c2d' name='w3'/>
	<parameter type-id='9c313c2d' name='w4'/>
	<return type-id='9c313c2d'/>
	</function-decl>
	</abi-instr>
	- <abi-instr version='1.0' address-size='64' path='../../module/zcommon/zfeature_common.c' language='LANG_C89'>
	+ <abi-instr address-size='64' path='../../module/zcommon/zfeature_common.c' language='LANG_C99'>
	<array-type-def dimensions='1' type-id='83f29ca2' size-in-bits='15232' id='d96379d0'>
	- <subrange length='34' type-id='4c87fef4' id='6a6a7e00'/>
	+ <subrange length='34' type-id='7359adad' id='6a6a7e00'/>
	</array-type-def>
	- <typedef-decl name='zfeature_info_t' type-id='1178d146' id='83f29ca2'/>
	+ <enum-decl name='zfeature_flags' id='6db816a4'>
	+ <underlying-type type-id='9cac1fee'/>
	+ <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='6db816a4' id='fc329033'/>
	+ <enum-decl name='zfeature_type' id='c4fa2355'>
	+ <underlying-type type-id='9cac1fee'/>
	+ <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='c4fa2355' id='732d2bb2'/>
	<class-decl name='zfeature_info' size-in-bits='448' is-struct='yes' visibility='default' id='1178d146'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='fi_feature' type-id='d6618c78' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='fi_uname' type-id='80f4b756' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='fi_guid' type-id='80f4b756' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	<var-decl name='fi_desc' type-id='80f4b756' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='256'>
	<var-decl name='fi_flags' type-id='fc329033' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='288'>
	<var-decl name='fi_zfs_mod_supported' type-id='c19b74c3' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='320'>
	<var-decl name='fi_type' type-id='732d2bb2' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='384'>
	<var-decl name='fi_depends' type-id='1acff326' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='zfeature_flags_t' type-id='6db816a4' id='fc329033'/>
	- <enum-decl name='zfeature_flags' id='6db816a4'>
	- <underlying-type type-id='9cac1fee'/>
	- <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_type_t' type-id='c4fa2355' id='732d2bb2'/>
	- <enum-decl name='zfeature_type' id='c4fa2355'>
	- <underlying-type type-id='9cac1fee'/>
	- <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_info_t' type-id='1178d146' id='83f29ca2'/>
	<qualified-type-def type-id='d6618c78' const='yes' id='81a65028'/>
	<pointer-type-def type-id='81a65028' size-in-bits='64' id='1acff326'/>
	+ <var-decl name='spa_feature_table' type-id='d96379d0' mangled-name='spa_feature_table' visibility='default' elf-symbol-id='spa_feature_table'/>
	+ <var-decl name='zfeature_checks_disable' type-id='c19b74c3' mangled-name='zfeature_checks_disable' visibility='default' elf-symbol-id='zfeature_checks_disable'/>
	<function-decl name='zfeature_is_valid_guid' mangled-name='zfeature_is_valid_guid' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfeature_is_valid_guid'>
	<parameter type-id='80f4b756' name='name'/>
	<return type-id='c19b74c3'/>
	</function-decl>
	<function-decl name='zfeature_depends_on' mangled-name='zfeature_depends_on' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfeature_depends_on'>
	<parameter type-id='d6618c78' name='fid'/>
	<parameter type-id='d6618c78' name='check'/>
	<return type-id='c19b74c3'/>
	</function-decl>
	<function-decl name='zfs_mod_supported' mangled-name='zfs_mod_supported' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_mod_supported'>
	<parameter type-id='80f4b756' name='scope'/>
	<parameter type-id='80f4b756' name='name'/>
	<return type-id='c19b74c3'/>
	</function-decl>
	- <var-decl name='spa_feature_table' type-id='d96379d0' mangled-name='spa_feature_table' visibility='default' elf-symbol-id='spa_feature_table'/>
	- <var-decl name='zfeature_checks_disable' type-id='c19b74c3' mangled-name='zfeature_checks_disable' visibility='default' elf-symbol-id='zfeature_checks_disable'/>
	- <typedef-decl name='spa_feature_t' type-id='33ecb627' id='d6618c78'/>
	- <enum-decl name='spa_feature' id='33ecb627'>
	- <underlying-type type-id='9cac1fee'/>
	- <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>
	</abi-instr>
	- <abi-instr version='1.0' address-size='64' path='../../module/zcommon/zfs_comutil.c' language='LANG_C89'>
	+ <abi-instr address-size='64' path='../../module/zcommon/zfs_comutil.c' language='LANG_C99'>
	<array-type-def dimensions='1' type-id='80f4b756' size-in-bits='2624' id='ef31fedf'>
	- <subrange length='41' type-id='4c87fef4' id='cb834f44'/>
	+ <subrange length='41' type-id='7359adad' id='cb834f44'/>
	</array-type-def>
	<pointer-type-def type-id='8f92235e' size-in-bits='64' id='90421557'/>
	+ <function-decl name='nvpair_value_uint32' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='3fa542f0'/>
	+ <parameter type-id='90421557'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <var-decl name='zfs_history_event_names' type-id='ef31fedf' mangled-name='zfs_history_event_names' visibility='default' elf-symbol-id='zfs_history_event_names'/>
	<function-decl name='zfs_allocatable_devs' mangled-name='zfs_allocatable_devs' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_allocatable_devs'>
	<parameter type-id='5ce45b60' name='nv'/>
	<return type-id='c19b74c3'/>
	</function-decl>
	<function-decl name='zfs_special_devs' mangled-name='zfs_special_devs' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_special_devs'>
	<parameter type-id='5ce45b60' name='nv'/>
	<parameter type-id='26a90f95' name='type'/>
	<return type-id='c19b74c3'/>
	</function-decl>
	<function-decl name='zfs_zpl_version_map' mangled-name='zfs_zpl_version_map' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_zpl_version_map'>
	<parameter type-id='95e97e5e' name='spa_version'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='zfs_spa_version_map' mangled-name='zfs_spa_version_map' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_spa_version_map'>
	<parameter type-id='95e97e5e' name='zpl_version'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='zfs_dataset_name_hidden' mangled-name='zfs_dataset_name_hidden' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_dataset_name_hidden'>
	<parameter type-id='80f4b756' name='name'/>
	<return type-id='c19b74c3'/>
	</function-decl>
	- <var-decl name='zfs_history_event_names' type-id='ef31fedf' mangled-name='zfs_history_event_names' visibility='default' elf-symbol-id='zfs_history_event_names'/>
	- <function-decl name='nvpair_value_uint32' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='3fa542f0'/>
	- <parameter type-id='90421557'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <pointer-type-def type-id='8e8d4be3' size-in-bits='64' id='5ce45b60'/>
	- <pointer-type-def type-id='57928edf' size-in-bits='64' id='3fa542f0'/>
	- <typedef-decl name='nvlist_t' type-id='ac266fd9' id='8e8d4be3'/>
	- <typedef-decl name='nvpair_t' type-id='1c34e459' id='57928edf'/>
	- <class-decl name='nvlist' size-in-bits='192' is-struct='yes' visibility='default' id='ac266fd9'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='nvl_version' type-id='3ff5601b' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='32'>
	- <var-decl name='nvl_nvflag' type-id='8f92235e' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='nvl_priv' type-id='9c313c2d' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='nvl_flag' type-id='8f92235e' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='160'>
	- <var-decl name='nvl_pad' type-id='3ff5601b' visibility='default'/>
	- </data-member>
	- </class-decl>
	- <class-decl name='nvpair' size-in-bits='128' is-struct='yes' visibility='default' id='1c34e459'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='nvp_size' type-id='3ff5601b' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='32'>
	- <var-decl name='nvp_name_sz' type-id='23bd8cb5' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='48'>
	- <var-decl name='nvp_reserve' type-id='23bd8cb5' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='nvp_value_elem' type-id='3ff5601b' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='96'>
	- <var-decl name='nvp_type' type-id='8d0687d2' visibility='default'/>
	- </data-member>
	- </class-decl>
	- <typedef-decl name='data_type_t' type-id='08f5ca17' id='8d0687d2'/>
	- <typedef-decl name='int16_t' type-id='a2185560' id='23bd8cb5'/>
	- <typedef-decl name='int32_t' type-id='95e97e5e' id='3ff5601b'/>
	- <enum-decl name='__anonymous_enum__' is-anonymous='yes' id='08f5ca17'>
	- <underlying-type type-id='9cac1fee'/>
	- <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>
	- <type-decl name='short int' size-in-bits='16' id='a2185560'/>
	</abi-instr>
	- <abi-instr version='1.0' address-size='64' path='../../module/zcommon/zfs_deleg.c' language='LANG_C89'>
	+ <abi-instr address-size='64' path='../../module/zcommon/zfs_deleg.c' language='LANG_C99'>
	<array-type-def dimensions='1' type-id='f3f851ad' size-in-bits='4096' id='3dd2cc5f'>
	- <subrange length='32' type-id='4c87fef4' id='ae5bde82'/>
	+ <subrange length='32' type-id='7359adad' id='ae5bde82'/>
	</array-type-def>
	- <typedef-decl name='zfs_deleg_who_type_t' type-id='08f5ca18' id='36d4bd5a'/>
	- <enum-decl name='__anonymous_enum__' is-anonymous='yes' id='08f5ca18'>
	+ <array-type-def dimensions='1' type-id='f3f851ad' size-in-bits='infinite' id='bc4e5d90'>
	+ <subrange length='infinite' id='031f2035'/>
	+ </array-type-def>
	+ <enum-decl name='zfs_deleg_who_type_t' naming-typedef-id='36d4bd5a' id='b5fa5816'>
	<underlying-type type-id='9cac1fee'/>
	<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_perm_tab_t' type-id='5aa05c1f' id='f3f851ad'/>
	- <class-decl name='zfs_deleg_perm_tab' size-in-bits='128' is-struct='yes' visibility='default' id='5aa05c1f'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='z_perm' type-id='26a90f95' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='z_note' type-id='4613c173' visibility='default'/>
	- </data-member>
	- </class-decl>
	- <typedef-decl name='zfs_deleg_note_t' type-id='40ed39d3' id='4613c173'/>
	- <enum-decl name='__anonymous_enum__1' is-anonymous='yes' id='40ed39d3'>
	+ <typedef-decl name='zfs_deleg_who_type_t' type-id='b5fa5816' id='36d4bd5a'/>
	+ <enum-decl name='zfs_deleg_note_t' naming-typedef-id='4613c173' id='729d4547'>
	<underlying-type type-id='9cac1fee'/>
	<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='729d4547' id='4613c173'/>
	+ <class-decl name='zfs_deleg_perm_tab' size-in-bits='128' is-struct='yes' visibility='default' id='5aa05c1f'>
	+ <data-member access='public' layout-offset-in-bits='0'>
	+ <var-decl name='z_perm' type-id='26a90f95' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='64'>
	+ <var-decl name='z_note' type-id='4613c173' visibility='default'/>
	+ </data-member>
	+ </class-decl>
	+ <typedef-decl name='zfs_deleg_perm_tab_t' type-id='5aa05c1f' id='f3f851ad'/>
	+ <var-decl name='zfs_deleg_perm_tab' type-id='bc4e5d90' mangled-name='zfs_deleg_perm_tab' visibility='default' elf-symbol-id='zfs_deleg_perm_tab'/>
	+ <function-decl name='permset_namecheck' mangled-name='permset_namecheck' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='permset_namecheck'>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='053457bd'/>
	+ <parameter type-id='26a90f95'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='zfs_prop_delegatable' mangled-name='zfs_prop_delegatable' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_delegatable'>
	+ <parameter type-id='58603c44'/>
	+ <return type-id='c19b74c3'/>
	+ </function-decl>
	<function-decl name='zfs_deleg_canonicalize_perm' mangled-name='zfs_deleg_canonicalize_perm' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_deleg_canonicalize_perm'>
	<parameter type-id='80f4b756' name='perm'/>
	<return type-id='80f4b756'/>
	</function-decl>
	<function-decl name='zfs_deleg_verify_nvlist' mangled-name='zfs_deleg_verify_nvlist' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_deleg_verify_nvlist'>
	<parameter type-id='5ce45b60' name='nvp'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='zfs_deleg_whokey' mangled-name='zfs_deleg_whokey' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_deleg_whokey'>
	<parameter type-id='26a90f95' name='attr'/>
	<parameter type-id='36d4bd5a' name='type'/>
	<parameter type-id='a84c031d' name='inheritchr'/>
	<parameter type-id='eaa32e2f' name='data'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <var-decl name='zfs_deleg_perm_tab' type-id='3dd2cc5f' mangled-name='zfs_deleg_perm_tab' visibility='default' elf-symbol-id='zfs_deleg_perm_tab'/>
	- <function-decl name='zfs_prop_delegatable' mangled-name='zfs_prop_delegatable' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_delegatable'>
	- <parameter type-id='58603c44'/>
	- <return type-id='c19b74c3'/>
	- </function-decl>
	- <function-decl name='permset_namecheck' mangled-name='permset_namecheck' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='permset_namecheck'>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='053457bd'/>
	- <parameter type-id='26a90f95'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <pointer-type-def type-id='8e0af06e' size-in-bits='64' id='053457bd'/>
	- <typedef-decl name='zfs_prop_t' type-id='08f5ca19' id='58603c44'/>
	- <enum-decl name='__anonymous_enum__' is-anonymous='yes' id='08f5ca19'>
	- <underlying-type type-id='9cac1fee'/>
	- <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='namecheck_err_t' type-id='3eed36ac' id='8e0af06e'/>
	- <enum-decl name='__anonymous_enum__3' is-anonymous='yes' id='3eed36ac'>
	- <underlying-type type-id='9cac1fee'/>
	- <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>
	</abi-instr>
	- <abi-instr version='1.0' address-size='64' path='../../module/zcommon/zfs_fletcher.c' language='LANG_C89'>
	+ <abi-instr address-size='64' path='../../module/zcommon/zfs_fletcher.c' language='LANG_C99'>
	<array-type-def dimensions='1' type-id='90dbb6d6' size-in-bits='2048' id='16582e69'>
	- <subrange length='4' type-id='4c87fef4' id='16fe7105'/>
	+ <subrange length='4' type-id='7359adad' id='16fe7105'/>
	</array-type-def>
	<array-type-def dimensions='1' type-id='8240361c' size-in-bits='1024' id='481f90b1'>
	- <subrange length='4' type-id='4c87fef4' id='16fe7105'/>
	+ <subrange length='4' type-id='7359adad' id='16fe7105'/>
	</array-type-def>
	<array-type-def dimensions='1' type-id='7c1ab40c' size-in-bits='512' id='cbd91ec1'>
	- <subrange length='4' type-id='4c87fef4' id='16fe7105'/>
	+ <subrange length='4' type-id='7359adad' id='16fe7105'/>
	</array-type-def>
	<array-type-def dimensions='1' type-id='6d059eaa' size-in-bits='1024' id='729b6ebb'>
	- <subrange length='4' type-id='4c87fef4' id='16fe7105'/>
	+ <subrange length='4' type-id='7359adad' id='16fe7105'/>
	</array-type-def>
	- <typedef-decl name='zio_abd_checksum_func_t' type-id='3f8e8d11' id='c2eb138a'/>
	- <class-decl name='zio_abd_checksum_func' size-in-bits='192' is-struct='yes' visibility='default' id='aa14691a'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='acf_init' type-id='0bcca125' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='acf_fini' type-id='bfe36153' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='acf_iter' type-id='1e276399' visibility='default'/>
	- </data-member>
	- </class-decl>
	- <typedef-decl name='zio_abd_checksum_init_t' type-id='a5444274' id='029a8ebe'/>
	- <typedef-decl name='zio_abd_checksum_data_t' type-id='4bf4b004' id='74e39470'/>
	+ <enum-decl name='zio_byteorder_t' naming-typedef-id='595a65ec' id='fc861be0'>
	+ <underlying-type type-id='9cac1fee'/>
	+ <enumerator name='ZIO_CHECKSUM_NATIVE' value='0'/>
	+ <enumerator name='ZIO_CHECKSUM_BYTESWAP' value='1'/>
	+ </enum-decl>
	+ <typedef-decl name='zio_byteorder_t' type-id='fc861be0' id='595a65ec'/>
	<class-decl name='zio_abd_checksum_data' size-in-bits='256' is-struct='yes' visibility='default' id='4bf4b004'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='acd_byteorder' type-id='595a65ec' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='acd_ctx' type-id='0f7df99e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='acd_zcp' type-id='c24fc2ee' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	<var-decl name='acd_private' type-id='eaa32e2f' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='zio_byteorder_t' type-id='08f5ca1a' id='595a65ec'/>
	- <enum-decl name='__anonymous_enum__' is-anonymous='yes' id='08f5ca1a'>
	- <underlying-type type-id='9cac1fee'/>
	- <enumerator name='ZIO_CHECKSUM_NATIVE' value='0'/>
	- <enumerator name='ZIO_CHECKSUM_BYTESWAP' value='1'/>
	- </enum-decl>
	- <typedef-decl name='fletcher_4_ctx_t' type-id='1f951ade' id='4b675395'/>
	- <union-decl name='fletcher_4_ctx' size-in-bits='2048' visibility='default' id='1f951ade'>
	- <data-member access='private'>
	- <var-decl name='scalar' type-id='39730d0b' visibility='default'/>
	- </data-member>
	- <data-member access='private'>
	- <var-decl name='superscalar' type-id='729b6ebb' visibility='default'/>
	- </data-member>
	- <data-member access='private'>
	- <var-decl name='sse' type-id='cbd91ec1' visibility='default'/>
	+ <typedef-decl name='zio_abd_checksum_data_t' type-id='4bf4b004' id='74e39470'/>
	+ <typedef-decl name='zio_abd_checksum_init_t' type-id='a5444274' id='029a8ebe'/>
	+ <typedef-decl name='zio_abd_checksum_fini_t' type-id='a5444274' id='d6fd5c6c'/>
	+ <typedef-decl name='zio_abd_checksum_iter_t' type-id='f4a1892e' id='cefa0f4a'/>
	+ <class-decl name='zio_abd_checksum_func' size-in-bits='192' is-struct='yes' visibility='default' id='aa14691a'>
	+ <data-member access='public' layout-offset-in-bits='0'>
	+ <var-decl name='acf_init' type-id='0bcca125' visibility='default'/>
	</data-member>
	- <data-member access='private'>
	- <var-decl name='avx' type-id='481f90b1' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='64'>
	+ <var-decl name='acf_fini' type-id='bfe36153' visibility='default'/>
	</data-member>
	- <data-member access='private'>
	- <var-decl name='avx512' type-id='16582e69' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='128'>
	+ <var-decl name='acf_iter' type-id='1e276399' visibility='default'/>
	</data-member>
	- </union-decl>
	- <typedef-decl name='zfs_fletcher_superscalar_t' type-id='28efb250' id='6d059eaa'/>
	+ </class-decl>
	+ <typedef-decl name='zio_abd_checksum_func_t' type-id='3f8e8d11' id='c2eb138a'/>
	<class-decl name='zfs_fletcher_superscalar' size-in-bits='256' is-struct='yes' visibility='default' id='28efb250'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='v' type-id='85c64d26' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='zfs_fletcher_sse_t' type-id='acd4019a' id='7c1ab40c'/>
	+ <typedef-decl name='zfs_fletcher_superscalar_t' type-id='28efb250' id='6d059eaa'/>
	<class-decl name='zfs_fletcher_sse' size-in-bits='128' is-struct='yes' visibility='default' id='acd4019a'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='v' type-id='c1c22e6c' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='zfs_fletcher_avx_t' type-id='8c208dfa' id='8240361c'/>
	+ <typedef-decl name='zfs_fletcher_sse_t' type-id='acd4019a' id='7c1ab40c'/>
	<class-decl name='zfs_fletcher_avx' size-in-bits='256' is-struct='yes' visibility='default' id='8c208dfa'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='v' type-id='85c64d26' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='zfs_fletcher_avx512_t' type-id='c6d0c382' id='90dbb6d6'/>
	+ <typedef-decl name='zfs_fletcher_avx_t' type-id='8c208dfa' id='8240361c'/>
	<class-decl name='zfs_fletcher_avx512' size-in-bits='512' is-struct='yes' visibility='default' id='c6d0c382'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='v' type-id='c5d13f42' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='zio_abd_checksum_fini_t' type-id='a5444274' id='d6fd5c6c'/>
	- <typedef-decl name='zio_abd_checksum_iter_t' type-id='f4a1892e' id='cefa0f4a'/>
	+ <typedef-decl name='zfs_fletcher_avx512_t' type-id='c6d0c382' id='90dbb6d6'/>
	+ <union-decl name='fletcher_4_ctx' size-in-bits='2048' visibility='default' id='1f951ade'>
	+ <data-member access='public'>
	+ <var-decl name='scalar' type-id='39730d0b' visibility='default'/>
	+ </data-member>
	+ <data-member access='public'>
	+ <var-decl name='superscalar' type-id='729b6ebb' visibility='default'/>
	+ </data-member>
	+ <data-member access='public'>
	+ <var-decl name='sse' type-id='cbd91ec1' visibility='default'/>
	+ </data-member>
	+ <data-member access='public'>
	+ <var-decl name='avx' type-id='481f90b1' visibility='default'/>
	+ </data-member>
	+ <data-member access='public'>
	+ <var-decl name='avx512' type-id='16582e69' visibility='default'/>
	+ </data-member>
	+ </union-decl>
	+ <typedef-decl name='fletcher_4_ctx_t' type-id='1f951ade' id='4b675395'/>
	<qualified-type-def type-id='aa14691a' const='yes' id='3f8e8d11'/>
	<pointer-type-def type-id='4b675395' size-in-bits='64' id='0f7df99e'/>
	<qualified-type-def type-id='8f92235e' volatile='yes' id='430e0681'/>
	<pointer-type-def type-id='430e0681' size-in-bits='64' id='3a147f31'/>
	<pointer-type-def type-id='74e39470' size-in-bits='64' id='eefe7427'/>
	<pointer-type-def type-id='d6fd5c6c' size-in-bits='64' id='bfe36153'/>
	<pointer-type-def type-id='029a8ebe' size-in-bits='64' id='0bcca125'/>
	<pointer-type-def type-id='cefa0f4a' size-in-bits='64' id='1e276399'/>
	+ <var-decl name='fletcher_4_abd_ops' type-id='c2eb138a' mangled-name='fletcher_4_abd_ops' visibility='default' elf-symbol-id='fletcher_4_abd_ops'/>
	+ <function-decl name='atomic_swap_32' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='3a147f31'/>
	+ <parameter type-id='8f92235e'/>
	+ <return type-id='8f92235e'/>
	+ </function-decl>
	+ <function-decl name='membar_producer' visibility='default' binding='global' size-in-bits='64'>
	+ <return type-id='48b5725f'/>
	+ </function-decl>
	<function-decl name='fletcher_init' mangled-name='fletcher_init' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fletcher_init'>
	<parameter type-id='c24fc2ee' name='zcp'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='fletcher_2_incremental_native' mangled-name='fletcher_2_incremental_native' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fletcher_2_incremental_native'>
	<parameter type-id='eaa32e2f' name='buf'/>
	<parameter type-id='b59d7dce' name='size'/>
	<parameter type-id='eaa32e2f' name='data'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='fletcher_2_native' mangled-name='fletcher_2_native' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fletcher_2_native'>
	<parameter type-id='eaa32e2f' name='buf'/>
	<parameter type-id='9c313c2d' name='size'/>
	<parameter type-id='eaa32e2f' name='ctx_template'/>
	<parameter type-id='c24fc2ee' name='zcp'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='fletcher_2_incremental_byteswap' mangled-name='fletcher_2_incremental_byteswap' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fletcher_2_incremental_byteswap'>
	<parameter type-id='eaa32e2f' name='buf'/>
	<parameter type-id='b59d7dce' name='size'/>
	<parameter type-id='eaa32e2f' name='data'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='fletcher_2_byteswap' mangled-name='fletcher_2_byteswap' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fletcher_2_byteswap'>
	<parameter type-id='eaa32e2f' name='buf'/>
	<parameter type-id='9c313c2d' name='size'/>
	<parameter type-id='eaa32e2f' name='ctx_template'/>
	<parameter type-id='c24fc2ee' name='zcp'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='fletcher_4_impl_set' mangled-name='fletcher_4_impl_set' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fletcher_4_impl_set'>
	<parameter type-id='80f4b756' name='val'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='fletcher_4_native' mangled-name='fletcher_4_native' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fletcher_4_native'>
	<parameter type-id='eaa32e2f' name='buf'/>
	<parameter type-id='9c313c2d' name='size'/>
	<parameter type-id='eaa32e2f' name='ctx_template'/>
	<parameter type-id='c24fc2ee' name='zcp'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='fletcher_4_byteswap' mangled-name='fletcher_4_byteswap' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fletcher_4_byteswap'>
	<parameter type-id='eaa32e2f' name='buf'/>
	<parameter type-id='9c313c2d' name='size'/>
	<parameter type-id='eaa32e2f' name='ctx_template'/>
	<parameter type-id='c24fc2ee' name='zcp'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <var-decl name='fletcher_4_abd_ops' type-id='c2eb138a' mangled-name='fletcher_4_abd_ops' visibility='default' elf-symbol-id='fletcher_4_abd_ops'/>
	- <function-decl name='atomic_swap_32' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='3a147f31'/>
	- <parameter type-id='8f92235e'/>
	- <return type-id='8f92235e'/>
	- </function-decl>
	- <function-decl name='membar_producer' visibility='default' binding='global' size-in-bits='64'>
	- <return type-id='48b5725f'/>
	- </function-decl>
	<function-type size-in-bits='64' id='f4a1892e'>
	- <parameter type-id='eaa32e2f' name='buf'/>
	- <parameter type-id='b59d7dce' name='size'/>
	- <parameter type-id='eaa32e2f' name='data'/>
	+ <parameter type-id='eaa32e2f'/>
	+ <parameter type-id='b59d7dce'/>
	+ <parameter type-id='eaa32e2f'/>
	<return type-id='95e97e5e'/>
	</function-type>
	<function-type size-in-bits='64' id='a5444274'>
	<parameter type-id='eefe7427'/>
	<return type-id='48b5725f'/>
	</function-type>
	- <typedef-decl name='zio_cksum_t' type-id='1d53e28b' id='39730d0b'/>
	- <array-type-def dimensions='1' type-id='9c313c2d' size-in-bits='256' id='85c64d26'>
	- <subrange length='4' type-id='4c87fef4' id='16fe7105'/>
	- </array-type-def>
	- <pointer-type-def type-id='39730d0b' size-in-bits='64' id='c24fc2ee'/>
	- <class-decl name='zio_cksum' size-in-bits='256' is-struct='yes' visibility='default' id='1d53e28b'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='zc_word' type-id='85c64d26' visibility='default'/>
	- </data-member>
	- </class-decl>
	</abi-instr>
	- <abi-instr version='1.0' address-size='64' path='../../module/zcommon/zfs_fletcher_avx512.c' language='LANG_C89'>
	- <typedef-decl name='fletcher_4_ops_t' type-id='57f479a0' id='eba91718'/>
	+ <abi-instr address-size='64' path='../../module/zcommon/zfs_fletcher_avx512.c' language='LANG_C99'>
	+ <typedef-decl name='fletcher_4_init_f' type-id='173aa527' id='b9ae1656'/>
	+ <typedef-decl name='fletcher_4_fini_f' type-id='0ad5b8a8' id='c4c1f4fc'/>
	+ <typedef-decl name='fletcher_4_compute_f' type-id='38147eff' id='ad1dc4cb'/>
	<class-decl name='fletcher_4_func' size-in-bits='512' is-struct='yes' visibility='default' id='57f479a0'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='init_native' type-id='b9ae1656' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='fini_native' type-id='c4c1f4fc' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='compute_native' type-id='ad1dc4cb' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	<var-decl name='init_byteswap' type-id='b9ae1656' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='256'>
	<var-decl name='fini_byteswap' type-id='c4c1f4fc' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='320'>
	<var-decl name='compute_byteswap' type-id='ad1dc4cb' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='384'>
	<var-decl name='valid' type-id='297d38bc' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='448'>
	<var-decl name='name' type-id='80f4b756' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='fletcher_4_init_f' type-id='173aa527' id='b9ae1656'/>
	- <typedef-decl name='fletcher_4_fini_f' type-id='0ad5b8a8' id='c4c1f4fc'/>
	- <typedef-decl name='fletcher_4_compute_f' type-id='38147eff' id='ad1dc4cb'/>
	+ <typedef-decl name='fletcher_4_ops_t' type-id='57f479a0' id='eba91718'/>
	<qualified-type-def type-id='eba91718' const='yes' id='9eeabdc8'/>
	<pointer-type-def type-id='e9e61702' size-in-bits='64' id='297d38bc'/>
	<pointer-type-def type-id='fe40251b' size-in-bits='64' id='173aa527'/>
	<pointer-type-def type-id='17fb1f83' size-in-bits='64' id='38147eff'/>
	<pointer-type-def type-id='fb39e25e' size-in-bits='64' id='0ad5b8a8'/>
	<var-decl name='fletcher_4_avx512f_ops' type-id='9eeabdc8' mangled-name='fletcher_4_avx512f_ops' visibility='default' elf-symbol-id='fletcher_4_avx512f_ops'/>
	<var-decl name='fletcher_4_avx512bw_ops' type-id='9eeabdc8' mangled-name='fletcher_4_avx512bw_ops' visibility='default' elf-symbol-id='fletcher_4_avx512bw_ops'/>
	<function-type size-in-bits='64' id='e9e61702'>
	<return type-id='c19b74c3'/>
	</function-type>
	<function-type size-in-bits='64' id='fe40251b'>
	<parameter type-id='0f7df99e'/>
	<return type-id='48b5725f'/>
	</function-type>
	<function-type size-in-bits='64' id='17fb1f83'>
	<parameter type-id='0f7df99e'/>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='9c313c2d'/>
	<return type-id='48b5725f'/>
	</function-type>
	<function-type size-in-bits='64' id='fb39e25e'>
	<parameter type-id='0f7df99e'/>
	<parameter type-id='c24fc2ee'/>
	<return type-id='48b5725f'/>
	</function-type>
	</abi-instr>
	- <abi-instr version='1.0' address-size='64' path='../../module/zcommon/zfs_fletcher_intel.c' language='LANG_C89'>
	+ <abi-instr address-size='64' path='../../module/zcommon/zfs_fletcher_intel.c' language='LANG_C99'>
	<var-decl name='fletcher_4_avx2_ops' type-id='9eeabdc8' mangled-name='fletcher_4_avx2_ops' visibility='default' elf-symbol-id='fletcher_4_avx2_ops'/>
	</abi-instr>
	- <abi-instr version='1.0' address-size='64' path='../../module/zcommon/zfs_fletcher_sse.c' language='LANG_C89'>
	+ <abi-instr address-size='64' path='../../module/zcommon/zfs_fletcher_sse.c' language='LANG_C99'>
	<var-decl name='fletcher_4_sse2_ops' type-id='9eeabdc8' mangled-name='fletcher_4_sse2_ops' visibility='default' elf-symbol-id='fletcher_4_sse2_ops'/>
	<var-decl name='fletcher_4_ssse3_ops' type-id='9eeabdc8' mangled-name='fletcher_4_ssse3_ops' visibility='default' elf-symbol-id='fletcher_4_ssse3_ops'/>
	</abi-instr>
	- <abi-instr version='1.0' address-size='64' path='../../module/zcommon/zfs_fletcher_superscalar.c' language='LANG_C89'>
	+ <abi-instr address-size='64' path='../../module/zcommon/zfs_fletcher_superscalar.c' language='LANG_C99'>
	<var-decl name='fletcher_4_superscalar_ops' type-id='9eeabdc8' mangled-name='fletcher_4_superscalar_ops' visibility='default' elf-symbol-id='fletcher_4_superscalar_ops'/>
	</abi-instr>
	- <abi-instr version='1.0' address-size='64' path='../../module/zcommon/zfs_fletcher_superscalar4.c' language='LANG_C89'>
	+ <abi-instr address-size='64' path='../../module/zcommon/zfs_fletcher_superscalar4.c' language='LANG_C99'>
	<var-decl name='fletcher_4_superscalar4_ops' type-id='9eeabdc8' mangled-name='fletcher_4_superscalar4_ops' visibility='default' elf-symbol-id='fletcher_4_superscalar4_ops'/>
	</abi-instr>
	- <abi-instr version='1.0' address-size='64' path='../../module/zcommon/zfs_namecheck.c' language='LANG_C89'>
	+ <abi-instr address-size='64' path='../../module/zcommon/zfs_namecheck.c' language='LANG_C99'>
	+ <var-decl name='zfs_max_dataset_nesting' type-id='95e97e5e' mangled-name='zfs_max_dataset_nesting' visibility='default' elf-symbol-id='zfs_max_dataset_nesting'/>
	<function-decl name='get_dataset_depth' mangled-name='get_dataset_depth' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='get_dataset_depth'>
	<parameter type-id='80f4b756' name='path'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='zfs_component_namecheck' mangled-name='zfs_component_namecheck' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_component_namecheck'>
	<parameter type-id='80f4b756' name='path'/>
	<parameter type-id='053457bd' name='why'/>
	<parameter type-id='26a90f95' name='what'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='dataset_namecheck' mangled-name='dataset_namecheck' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='dataset_namecheck'>
	<parameter type-id='80f4b756' name='path'/>
	<parameter type-id='053457bd' name='why'/>
	<parameter type-id='26a90f95' name='what'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='bookmark_namecheck' mangled-name='bookmark_namecheck' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='bookmark_namecheck'>
	<parameter type-id='80f4b756' name='path'/>
	<parameter type-id='053457bd' name='why'/>
	<parameter type-id='26a90f95' name='what'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='snapshot_namecheck' mangled-name='snapshot_namecheck' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='snapshot_namecheck'>
	<parameter type-id='80f4b756' name='path'/>
	<parameter type-id='053457bd' name='why'/>
	<parameter type-id='26a90f95' name='what'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <var-decl name='zfs_max_dataset_nesting' type-id='95e97e5e' mangled-name='zfs_max_dataset_nesting' visibility='default' elf-symbol-id='zfs_max_dataset_nesting'/>
	</abi-instr>
	- <abi-instr version='1.0' address-size='64' path='../../module/zcommon/zfs_prop.c' language='LANG_C89'>
	+ <abi-instr address-size='64' path='../../module/zcommon/zfs_prop.c' language='LANG_C99'>
	<array-type-def dimensions='1' type-id='80f4b756' size-in-bits='768' id='35e4b367'>
	- <subrange length='12' type-id='4c87fef4' id='84827bdc'/>
	+ <subrange length='12' type-id='7359adad' id='84827bdc'/>
	</array-type-def>
	- <function-decl name='zfs_prop_string_to_index' mangled-name='zfs_prop_string_to_index' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_string_to_index'>
	- <parameter type-id='58603c44' name='prop'/>
	- <parameter type-id='80f4b756' name='string'/>
	- <parameter type-id='5d6479ae' name='index'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='zfs_prop_random_value' mangled-name='zfs_prop_random_value' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_random_value'>
	- <parameter type-id='58603c44' name='prop'/>
	- <parameter type-id='9c313c2d' name='seed'/>
	- <return type-id='9c313c2d'/>
	- </function-decl>
	- <function-decl name='zfs_prop_visible' mangled-name='zfs_prop_visible' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_visible'>
	- <parameter type-id='58603c44' name='prop'/>
	- <return type-id='c19b74c3'/>
	- </function-decl>
	- <function-decl name='zfs_prop_values' mangled-name='zfs_prop_values' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_values'>
	- <parameter type-id='58603c44' name='prop'/>
	- <return type-id='80f4b756'/>
	- </function-decl>
	- <function-decl name='zfs_prop_is_string' mangled-name='zfs_prop_is_string' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_is_string'>
	- <parameter type-id='58603c44' name='prop'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='zfs_prop_column_name' mangled-name='zfs_prop_column_name' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_column_name'>
	- <parameter type-id='58603c44' name='prop'/>
	- <return type-id='80f4b756'/>
	- </function-decl>
	- <function-decl name='zfs_prop_align_right' mangled-name='zfs_prop_align_right' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_align_right'>
	- <parameter type-id='58603c44' name='prop'/>
	- <return type-id='c19b74c3'/>
	- </function-decl>
	<var-decl name='zfs_userquota_prop_prefixes' type-id='35e4b367' mangled-name='zfs_userquota_prop_prefixes' visibility='default' elf-symbol-id='zfs_userquota_prop_prefixes'/>
	- <function-decl name='zprop_register_index' mangled-name='zprop_register_index' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zprop_register_index'>
	+ <function-decl name='zprop_register_impl' mangled-name='zprop_register_impl' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zprop_register_impl'>
	<parameter type-id='95e97e5e'/>
	<parameter type-id='80f4b756'/>
	+ <parameter type-id='31429eff'/>
	<parameter type-id='9c313c2d'/>
	+ <parameter type-id='80f4b756'/>
	<parameter type-id='999701cc'/>
	<parameter type-id='95e97e5e'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='80f4b756'/>
	+ <parameter type-id='c19b74c3'/>
	+ <parameter type-id='c19b74c3'/>
	<parameter type-id='c8bc397b'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='zprop_register_string' mangled-name='zprop_register_string' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zprop_register_string'>
	<parameter type-id='95e97e5e'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='999701cc'/>
	<parameter type-id='95e97e5e'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='80f4b756'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='zprop_register_number' mangled-name='zprop_register_number' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zprop_register_number'>
	<parameter type-id='95e97e5e'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='9c313c2d'/>
	<parameter type-id='999701cc'/>
	<parameter type-id='95e97e5e'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='80f4b756'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='zprop_register_hidden' mangled-name='zprop_register_hidden' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zprop_register_hidden'>
	+ <function-decl name='zprop_register_index' mangled-name='zprop_register_index' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zprop_register_index'>
	<parameter type-id='95e97e5e'/>
	<parameter type-id='80f4b756'/>
	- <parameter type-id='31429eff'/>
	+ <parameter type-id='9c313c2d'/>
	<parameter type-id='999701cc'/>
	<parameter type-id='95e97e5e'/>
	<parameter type-id='80f4b756'/>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='c8bc397b'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='zprop_register_impl' mangled-name='zprop_register_impl' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zprop_register_impl'>
	+ <function-decl name='zprop_register_hidden' mangled-name='zprop_register_hidden' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zprop_register_hidden'>
	<parameter type-id='95e97e5e'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='31429eff'/>
	- <parameter type-id='9c313c2d'/>
	- <parameter type-id='80f4b756'/>
	<parameter type-id='999701cc'/>
	<parameter type-id='95e97e5e'/>
	<parameter type-id='80f4b756'/>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='c19b74c3'/>
	- <parameter type-id='c19b74c3'/>
	- <parameter type-id='c8bc397b'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='zprop_index_to_string' mangled-name='zprop_index_to_string' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zprop_index_to_string'>
	<parameter type-id='95e97e5e'/>
	<parameter type-id='9c313c2d'/>
	<parameter type-id='7d3cd834'/>
	<parameter type-id='2e45de5d'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='zprop_random_value' mangled-name='zprop_random_value' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zprop_random_value'>
	<parameter type-id='95e97e5e'/>
	<parameter type-id='9c313c2d'/>
	<parameter type-id='2e45de5d'/>
	<return type-id='9c313c2d'/>
	</function-decl>
	- <pointer-type-def type-id='80f4b756' size-in-bits='64' id='7d3cd834'/>
	- <pointer-type-def type-id='072f7953' size-in-bits='64' id='c8bc397b'/>
	- <typedef-decl name='zfs_type_t' type-id='3eed36ad' id='2e45de5d'/>
	- <typedef-decl name='zprop_attr_t' type-id='40ed39d4' id='999701cc'/>
	- <typedef-decl name='zprop_type_t' type-id='3fed383f' id='31429eff'/>
	- <pointer-type-def type-id='9c313c2d' size-in-bits='64' id='5d6479ae'/>
	- <qualified-type-def type-id='64636ce3' const='yes' id='072f7953'/>
	- <enum-decl name='__anonymous_enum__1' is-anonymous='yes' id='40ed39d4'>
	- <underlying-type type-id='9cac1fee'/>
	- <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>
	- <enum-decl name='__anonymous_enum__2' is-anonymous='yes' id='3fed383f'>
	- <underlying-type type-id='9cac1fee'/>
	- <enumerator name='PROP_TYPE_NUMBER' value='0'/>
	- <enumerator name='PROP_TYPE_STRING' value='1'/>
	- <enumerator name='PROP_TYPE_INDEX' value='2'/>
	- </enum-decl>
	- <enum-decl name='__anonymous_enum__3' is-anonymous='yes' id='3eed36ad'>
	- <underlying-type type-id='9cac1fee'/>
	- <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='zprop_index_t' type-id='87957af9' id='64636ce3'/>
	- <class-decl name='zfs_index' size-in-bits='128' is-struct='yes' visibility='default' id='87957af9'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='pi_name' type-id='80f4b756' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='pi_value' type-id='9c313c2d' visibility='default'/>
	- </data-member>
	- </class-decl>
	+ <function-decl name='zfs_prop_string_to_index' mangled-name='zfs_prop_string_to_index' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_string_to_index'>
	+ <parameter type-id='58603c44' name='prop'/>
	+ <parameter type-id='80f4b756' name='string'/>
	+ <parameter type-id='5d6479ae' name='index'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='zfs_prop_random_value' mangled-name='zfs_prop_random_value' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_random_value'>
	+ <parameter type-id='58603c44' name='prop'/>
	+ <parameter type-id='9c313c2d' name='seed'/>
	+ <return type-id='9c313c2d'/>
	+ </function-decl>
	+ <function-decl name='zfs_prop_visible' mangled-name='zfs_prop_visible' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_visible'>
	+ <parameter type-id='58603c44' name='prop'/>
	+ <return type-id='c19b74c3'/>
	+ </function-decl>
	+ <function-decl name='zfs_prop_values' mangled-name='zfs_prop_values' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_values'>
	+ <parameter type-id='58603c44' name='prop'/>
	+ <return type-id='80f4b756'/>
	+ </function-decl>
	+ <function-decl name='zfs_prop_is_string' mangled-name='zfs_prop_is_string' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_is_string'>
	+ <parameter type-id='58603c44' name='prop'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='zfs_prop_column_name' mangled-name='zfs_prop_column_name' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_column_name'>
	+ <parameter type-id='58603c44' name='prop'/>
	+ <return type-id='80f4b756'/>
	+ </function-decl>
	+ <function-decl name='zfs_prop_align_right' mangled-name='zfs_prop_align_right' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_align_right'>
	+ <parameter type-id='58603c44' name='prop'/>
	+ <return type-id='c19b74c3'/>
	+ </function-decl>
	</abi-instr>
	- <abi-instr version='1.0' address-size='64' path='../../module/zcommon/zpool_prop.c' language='LANG_C89'>
	+ <abi-instr address-size='64' path='../../module/zcommon/zpool_prop.c' language='LANG_C99'>
	<function-decl name='zpool_prop_string_to_index' mangled-name='zpool_prop_string_to_index' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_prop_string_to_index'>
	<parameter type-id='5d0c23fb' name='prop'/>
	<parameter type-id='80f4b756' name='string'/>
	<parameter type-id='5d6479ae' name='index'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='zpool_prop_random_value' mangled-name='zpool_prop_random_value' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_prop_random_value'>
	<parameter type-id='5d0c23fb' name='prop'/>
	<parameter type-id='9c313c2d' name='seed'/>
	<return type-id='9c313c2d'/>
	</function-decl>
	<function-decl name='zpool_prop_values' mangled-name='zpool_prop_values' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_prop_values'>
	<parameter type-id='5d0c23fb' name='prop'/>
	<return type-id='80f4b756'/>
	</function-decl>
	<function-decl name='zpool_prop_column_name' mangled-name='zpool_prop_column_name' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_prop_column_name'>
	<parameter type-id='5d0c23fb' name='prop'/>
	<return type-id='80f4b756'/>
	</function-decl>
	<function-decl name='zpool_prop_align_right' mangled-name='zpool_prop_align_right' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_prop_align_right'>
	<parameter type-id='5d0c23fb' name='prop'/>
	<return type-id='c19b74c3'/>
	</function-decl>
	- <typedef-decl name='zpool_prop_t' type-id='08f5ca1b' id='5d0c23fb'/>
	- <enum-decl name='__anonymous_enum__' is-anonymous='yes' id='08f5ca1b'>
	- <underlying-type type-id='9cac1fee'/>
	- <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>
	</abi-instr>
	- <abi-instr version='1.0' address-size='64' path='../../module/zcommon/zprop_common.c' language='LANG_C89'>
	+ <abi-instr address-size='64' path='../../module/zcommon/zprop_common.c' language='LANG_C99'>
	<function-decl name='__ctype_tolower_loc' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='24f95ba5'/>
	</function-decl>
	- <pointer-type-def type-id='a0de50cd' size-in-bits='64' id='24f95ba5'/>
	- <pointer-type-def type-id='21fd6035' size-in-bits='64' id='a0de50cd'/>
	- <qualified-type-def type-id='33f57a65' const='yes' id='21fd6035'/>
	- <typedef-decl name='__int32_t' type-id='95e97e5e' id='33f57a65'/>
	</abi-instr>
	- <abi-instr version='1.0' address-size='64' path='libzfs_changelist.c' language='LANG_C89'>
	+ <abi-instr address-size='64' path='libzfs_changelist.c' language='LANG_C99'>
	<array-type-def dimensions='1' type-id='bf311473' size-in-bits='128' id='f0f65199'>
	- <subrange length='2' type-id='4c87fef4' id='52efc4ef'/>
	+ <subrange length='2' type-id='7359adad' id='52efc4ef'/>
	</array-type-def>
	<type-decl name='char' size-in-bits='8' id='a84c031d'/>
	<array-type-def dimensions='1' type-id='a84c031d' size-in-bits='8192' id='b54ce520'>
	- <subrange length='1024' type-id='4c87fef4' id='c60446f8'/>
	+ <subrange length='1024' type-id='7359adad' id='c60446f8'/>
	</array-type-def>
	<array-type-def dimensions='1' type-id='a84c031d' size-in-bits='8' id='89feb1ec'>
	- <subrange length='1' type-id='4c87fef4' id='52f813b4'/>
	+ <subrange length='1' type-id='7359adad' id='52f813b4'/>
	</array-type-def>
	<array-type-def dimensions='1' type-id='a84c031d' size-in-bits='160' id='664ac0b7'>
	- <subrange length='20' type-id='4c87fef4' id='fdca39cf'/>
	+ <subrange length='20' type-id='7359adad' id='fdca39cf'/>
	</array-type-def>
	<array-type-def dimensions='1' type-id='a84c031d' size-in-bits='2048' id='d1617432'>
	- <subrange length='256' type-id='4c87fef4' id='36e5b9fa'/>
	+ <subrange length='256' type-id='7359adad' id='36e5b9fa'/>
	</array-type-def>
	<array-type-def dimensions='1' type-id='a84c031d' size-in-bits='320' id='36c46961'>
	- <subrange length='40' type-id='4c87fef4' id='8f80b239'/>
	+ <subrange length='40' type-id='7359adad' id='8f80b239'/>
	</array-type-def>
	+ <class-decl name='_IO_codecvt' is-struct='yes' visibility='default' is-declaration-only='yes' id='a4036571'/>
	+ <class-decl name='_IO_marker' is-struct='yes' visibility='default' is-declaration-only='yes' id='010ae0b9'/>
	+ <class-decl name='_IO_wide_data' is-struct='yes' visibility='default' is-declaration-only='yes' id='79bd3751'/>
	+ <class-decl name='re_dfa_t' is-struct='yes' visibility='default' is-declaration-only='yes' id='b48d2441'/>
	<class-decl name='uu_avl' is-struct='yes' visibility='default' is-declaration-only='yes' id='4af029d1'/>
	<class-decl name='uu_avl_pool' is-struct='yes' visibility='default' is-declaration-only='yes' id='12a530a8'/>
	<class-decl name='uu_avl_walk' is-struct='yes' visibility='default' is-declaration-only='yes' id='e70a39e3'/>
	<type-decl name='int' size-in-bits='32' id='95e97e5e'/>
	<type-decl name='long int' size-in-bits='64' id='bd54fe1a'/>
	<type-decl name='long long int' size-in-bits='64' id='1eb56b1e'/>
	<type-decl name='short int' size-in-bits='16' id='a2185560'/>
	<type-decl name='signed char' size-in-bits='8' id='28577a57'/>
	- <type-decl name='sizetype' size-in-bits='64' id='4c87fef4'/>
	<array-type-def dimensions='1' type-id='e475ab95' size-in-bits='192' id='0ce65a8b'>
	- <subrange length='3' type-id='4c87fef4' id='56f209d2'/>
	+ <subrange length='3' type-id='7359adad' id='56f209d2'/>
	</array-type-def>
	<type-decl name='unnamed-enum-underlying-type-32' is-anonymous='yes' size-in-bits='32' alignment-in-bits='32' id='9cac1fee'/>
	<type-decl name='unsigned char' size-in-bits='8' id='002ac4a6'/>
	<type-decl name='unsigned int' size-in-bits='32' id='f0981eeb'/>
	<type-decl name='unsigned long int' size-in-bits='64' id='7359adad'/>
	<type-decl name='unsigned short int' size-in-bits='16' id='8efea9e5'/>
	<type-decl name='void' id='48b5725f'/>
	- <typedef-decl name='prop_changelist_t' type-id='d86edc51' id='eae6431d'/>
	- <class-decl name='prop_changelist' size-in-bits='448' is-struct='yes' visibility='default' id='d86edc51'>
	+ <typedef-decl name='uu_compare_fn_t' type-id='add6e811' id='40f93560'/>
	+ <typedef-decl name='uu_avl_pool_t' type-id='12a530a8' id='7f84e390'/>
	+ <typedef-decl name='uu_avl_t' type-id='4af029d1' id='bb7f0973'/>
	+ <class-decl name='uu_avl_node' size-in-bits='192' is-struct='yes' visibility='default' id='f65f4326'>
	<data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='cl_prop' type-id='58603c44' visibility='default'/>
	+ <var-decl name='uan_opaque' type-id='0ce65a8b' visibility='default'/>
	+ </data-member>
	+ </class-decl>
	+ <typedef-decl name='uu_avl_node_t' type-id='f65f4326' id='73a65116'/>
	+ <typedef-decl name='uu_avl_walk_t' type-id='e70a39e3' id='edd8457b'/>
	+ <typedef-decl name='uu_avl_index_t' type-id='e475ab95' id='5d7f5fc8'/>
	+ <typedef-decl name='zfs_handle_t' type-id='f6ee4445' id='775509eb'/>
	+ <typedef-decl name='zpool_handle_t' type-id='67002a8a' id='b1efc708'/>
	+ <typedef-decl name='libzfs_handle_t' type-id='c8a9d9d8' id='95942d0c'/>
	+ <typedef-decl name='zfs_iter_f' type-id='5571cde4' id='d8e49ab9'/>
	+ <class-decl name='libzfs_handle' size-in-bits='20224' is-struct='yes' visibility='default' id='c8a9d9d8'>
	+ <data-member access='public' layout-offset-in-bits='0'>
	+ <var-decl name='libzfs_error' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='32'>
	- <var-decl name='cl_realprop' type-id='58603c44' visibility='default'/>
	+ <var-decl name='libzfs_fd' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='cl_shareprop' type-id='58603c44' visibility='default'/>
	+ <var-decl name='libzfs_mnttab' type-id='822cd80b' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='cl_pool' type-id='de82c773' visibility='default'/>
	+ <var-decl name='libzfs_pool_handles' type-id='4c81de99' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	- <var-decl name='cl_tree' type-id='a5c21a38' visibility='default'/>
	+ <var-decl name='libzfs_ns_avlpool' type-id='de82c773' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='256'>
	- <var-decl name='cl_waslegacy' type-id='c19b74c3' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='288'>
	- <var-decl name='cl_allchildren' type-id='c19b74c3' visibility='default'/>
	+ <var-decl name='libzfs_ns_avl' type-id='a5c21a38' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='320'>
	- <var-decl name='cl_alldependents' type-id='c19b74c3' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='352'>
	- <var-decl name='cl_mflags' type-id='95e97e5e' visibility='default'/>
	+ <var-decl name='libzfs_ns_gen' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='384'>
	- <var-decl name='cl_gflags' type-id='95e97e5e' visibility='default'/>
	+ <var-decl name='libzfs_desc_active' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='416'>
	- <var-decl name='cl_haszonedchild' type-id='c19b74c3' visibility='default'/>
	+ <var-decl name='libzfs_action' type-id='b54ce520' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='8608'>
	+ <var-decl name='libzfs_desc' type-id='b54ce520' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='16800'>
	+ <var-decl name='libzfs_printerr' type-id='95e97e5e' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='16832'>
	+ <var-decl name='libzfs_storeerr' type-id='95e97e5e' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='16864'>
	+ <var-decl name='libzfs_mnttab_enable' type-id='c19b74c3' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='16896'>
	+ <var-decl name='libzfs_mnttab_cache_lock' type-id='7a6844eb' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='17216'>
	+ <var-decl name='libzfs_mnttab_cache' type-id='f20fbd51' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='17536'>
	+ <var-decl name='libzfs_pool_iter' type-id='95e97e5e' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='17568'>
	+ <var-decl name='libzfs_chassis_id' type-id='d1617432' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='19616'>
	+ <var-decl name='libzfs_prop_debug' type-id='c19b74c3' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='19648'>
	+ <var-decl name='libzfs_urire' type-id='aca3bac8' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='20160'>
	+ <var-decl name='libzfs_max_nvlist' type-id='9c313c2d' visibility='default'/>
	+ </data-member>
	+ </class-decl>
	+ <class-decl name='zfs_handle' size-in-bits='4928' is-struct='yes' visibility='default' id='f6ee4445'>
	+ <data-member access='public' layout-offset-in-bits='0'>
	+ <var-decl name='zfs_hdl' type-id='b0382bb3' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='64'>
	+ <var-decl name='zpool_hdl' type-id='4c81de99' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='128'>
	+ <var-decl name='zfs_name' type-id='d1617432' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='2176'>
	+ <var-decl name='zfs_type' type-id='2e45de5d' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='2208'>
	+ <var-decl name='zfs_head_type' type-id='2e45de5d' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='2240'>
	+ <var-decl name='zfs_dmustats' type-id='b2c14f17' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='4544'>
	+ <var-decl name='zfs_props' type-id='5ce45b60' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='4608'>
	+ <var-decl name='zfs_user_props' type-id='5ce45b60' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='4672'>
	+ <var-decl name='zfs_recvd_props' type-id='5ce45b60' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='4736'>
	+ <var-decl name='zfs_mntcheck' type-id='c19b74c3' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='4800'>
	+ <var-decl name='zfs_mntopts' type-id='26a90f95' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='4864'>
	+ <var-decl name='zfs_props_table' type-id='ae3e8ca6' visibility='default'/>
	+ </data-member>
	+ </class-decl>
	+ <class-decl name='zpool_handle' size-in-bits='2560' is-struct='yes' visibility='default' id='67002a8a'>
	+ <data-member access='public' layout-offset-in-bits='0'>
	+ <var-decl name='zpool_hdl' type-id='b0382bb3' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='64'>
	+ <var-decl name='zpool_next' type-id='4c81de99' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='128'>
	+ <var-decl name='zpool_name' type-id='d1617432' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='2176'>
	+ <var-decl name='zpool_state' type-id='95e97e5e' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='2240'>
	+ <var-decl name='zpool_config_size' type-id='b59d7dce' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='2304'>
	+ <var-decl name='zpool_config' type-id='5ce45b60' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='2368'>
	+ <var-decl name='zpool_old_config' type-id='5ce45b60' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='2432'>
	+ <var-decl name='zpool_props' type-id='5ce45b60' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='2496'>
	+ <var-decl name='zpool_start_block' type-id='804dc465' visibility='default'/>
	+ </data-member>
	+ </class-decl>
	+ <enum-decl name='zfs_share_proto_t' naming-typedef-id='a7913f77' id='d34e3aab'>
	+ <underlying-type type-id='9cac1fee'/>
	+ <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='d34e3aab' id='a7913f77'/>
	+ <typedef-decl name='prop_changelist_t' type-id='d86edc51' id='eae6431d'/>
	+ <typedef-decl name='avl_tree_t' type-id='b351119f' id='f20fbd51'/>
	+ <class-decl name='avl_node' size-in-bits='192' is-struct='yes' visibility='default' id='428b67b3'>
	+ <data-member access='public' layout-offset-in-bits='0'>
	+ <var-decl name='avl_child' type-id='f0f65199' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='128'>
	+ <var-decl name='avl_pcb' type-id='e475ab95' visibility='default'/>
	+ </data-member>
	+ </class-decl>
	+ <class-decl name='avl_tree' size-in-bits='320' is-struct='yes' visibility='default' id='b351119f'>
	+ <data-member access='public' layout-offset-in-bits='0'>
	+ <var-decl name='avl_root' type-id='bf311473' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='64'>
	+ <var-decl name='avl_compar' type-id='585e1de9' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='128'>
	+ <var-decl name='avl_offset' type-id='b59d7dce' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='192'>
	+ <var-decl name='avl_numnodes' type-id='ee1f298e' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='256'>
	+ <var-decl name='avl_size' type-id='b59d7dce' visibility='default'/>
	+ </data-member>
	+ </class-decl>
	+ <class-decl name='dmu_objset_stats' size-in-bits='2304' is-struct='yes' visibility='default' id='098f0221'>
	+ <data-member access='public' layout-offset-in-bits='0'>
	+ <var-decl name='dds_num_clones' type-id='9c313c2d' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='64'>
	+ <var-decl name='dds_creation_txg' type-id='9c313c2d' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='128'>
	+ <var-decl name='dds_guid' type-id='9c313c2d' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='192'>
	+ <var-decl name='dds_type' type-id='230f1e16' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='224'>
	+ <var-decl name='dds_is_snapshot' type-id='b96825af' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='232'>
	+ <var-decl name='dds_inconsistent' type-id='b96825af' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='240'>
	+ <var-decl name='dds_redacted' type-id='b96825af' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='248'>
	+ <var-decl name='dds_origin' type-id='d1617432' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='zfs_prop_t' type-id='08f5ca19' id='58603c44'/>
	- <enum-decl name='__anonymous_enum__' is-anonymous='yes' id='08f5ca19'>
	+ <typedef-decl name='dmu_objset_stats_t' type-id='098f0221' id='b2c14f17'/>
	+ <enum-decl name='zfs_type_t' naming-typedef-id='2e45de5d' id='5d8f7321'>
	+ <underlying-type type-id='9cac1fee'/>
	+ <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='5d8f7321' id='2e45de5d'/>
	+ <enum-decl name='dmu_objset_type' id='6b1b19f9'>
	+ <underlying-type type-id='9cac1fee'/>
	+ <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='6b1b19f9' id='230f1e16'/>
	+ <enum-decl name='zfs_prop_t' naming-typedef-id='58603c44' id='4b000d60'>
	<underlying-type type-id='9cac1fee'/>
	<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='uu_avl_pool_t' type-id='12a530a8' id='7f84e390'/>
	- <typedef-decl name='uu_avl_t' type-id='4af029d1' id='bb7f0973'/>
	- <typedef-decl name='boolean_t' type-id='40ed39d2' id='c19b74c3'/>
	- <enum-decl name='__anonymous_enum__1' is-anonymous='yes' id='40ed39d2'>
	- <underlying-type type-id='9cac1fee'/>
	- <enumerator name='B_FALSE' value='0'/>
	- <enumerator name='B_TRUE' value='1'/>
	- </enum-decl>
	- <typedef-decl name='zfs_share_proto_t' type-id='3fed3840' id='a7913f77'/>
	- <enum-decl name='__anonymous_enum__2' is-anonymous='yes' id='3fed3840'>
	+ <typedef-decl name='zfs_prop_t' type-id='4b000d60' id='58603c44'/>
	+ <enum-decl name='zprop_source_t' naming-typedef-id='a2256d42' id='5903f80e'>
	<underlying-type type-id='9cac1fee'/>
	- <enumerator name='PROTO_NFS' value='0'/>
	- <enumerator name='PROTO_SMB' value='1'/>
	- <enumerator name='PROTO_END' value='2'/>
	+ <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='zfs_handle_t' type-id='f6ee4445' id='775509eb'/>
	- <class-decl name='zfs_handle' size-in-bits='4928' is-struct='yes' visibility='default' id='f6ee4445'>
	+ <typedef-decl name='zprop_source_t' type-id='5903f80e' id='a2256d42'/>
	+ <class-decl name='nvlist' size-in-bits='192' is-struct='yes' visibility='default' id='ac266fd9'>
	<data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='zfs_hdl' type-id='b0382bb3' visibility='default'/>
	+ <var-decl name='nvl_version' type-id='3ff5601b' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='32'>
	+ <var-decl name='nvl_nvflag' type-id='8f92235e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='zpool_hdl' type-id='4c81de99' visibility='default'/>
	+ <var-decl name='nvl_priv' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='zfs_name' type-id='d1617432' visibility='default'/>
	+ <var-decl name='nvl_flag' type-id='8f92235e' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='2176'>
	- <var-decl name='zfs_type' type-id='2e45de5d' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='2208'>
	- <var-decl name='zfs_head_type' type-id='2e45de5d' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='2240'>
	- <var-decl name='zfs_dmustats' type-id='b2c14f17' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='4544'>
	- <var-decl name='zfs_props' type-id='5ce45b60' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='4608'>
	- <var-decl name='zfs_user_props' type-id='5ce45b60' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='4672'>
	- <var-decl name='zfs_recvd_props' type-id='5ce45b60' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='4736'>
	- <var-decl name='zfs_mntcheck' type-id='c19b74c3' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='4800'>
	- <var-decl name='zfs_mntopts' type-id='26a90f95' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='4864'>
	- <var-decl name='zfs_props_table' type-id='ae3e8ca6' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='160'>
	+ <var-decl name='nvl_pad' type-id='3ff5601b' visibility='default'/>
	</data-member>
	</class-decl>
	- <class-decl name='libzfs_handle' size-in-bits='20224' is-struct='yes' visibility='default' id='c8a9d9d8'>
	+ <typedef-decl name='nvlist_t' type-id='ac266fd9' id='8e8d4be3'/>
	+ <enum-decl name='boolean_t' naming-typedef-id='c19b74c3' id='f58c8277'>
	+ <underlying-type type-id='9cac1fee'/>
	+ <enumerator name='B_FALSE' value='0'/>
	+ <enumerator name='B_TRUE' value='1'/>
	+ </enum-decl>
	+ <typedef-decl name='boolean_t' type-id='f58c8277' id='c19b74c3'/>
	+ <typedef-decl name='ulong_t' type-id='7359adad' id='ee1f298e'/>
	+ <typedef-decl name='longlong_t' type-id='1eb56b1e' id='9b3ff54f'/>
	+ <typedef-decl name='diskaddr_t' type-id='9b3ff54f' id='804dc465'/>
	+ <typedef-decl name='zoneid_t' type-id='95e97e5e' id='4da03624'/>
	+ <class-decl name='prop_changelist' size-in-bits='448' is-struct='yes' visibility='default' id='d86edc51'>
	<data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='libzfs_error' type-id='95e97e5e' visibility='default'/>
	+ <var-decl name='cl_prop' type-id='58603c44' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='32'>
	- <var-decl name='libzfs_fd' type-id='95e97e5e' visibility='default'/>
	+ <var-decl name='cl_realprop' type-id='58603c44' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='libzfs_mnttab' type-id='822cd80b' visibility='default'/>
	+ <var-decl name='cl_shareprop' type-id='58603c44' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='libzfs_pool_handles' type-id='4c81de99' visibility='default'/>
	+ <var-decl name='cl_pool' type-id='de82c773' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	- <var-decl name='libzfs_ns_avlpool' type-id='de82c773' visibility='default'/>
	+ <var-decl name='cl_tree' type-id='a5c21a38' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='256'>
	- <var-decl name='libzfs_ns_avl' type-id='a5c21a38' visibility='default'/>
	+ <var-decl name='cl_waslegacy' type-id='c19b74c3' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='288'>
	+ <var-decl name='cl_allchildren' type-id='c19b74c3' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='320'>
	- <var-decl name='libzfs_ns_gen' type-id='9c313c2d' visibility='default'/>
	+ <var-decl name='cl_alldependents' type-id='c19b74c3' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='352'>
	+ <var-decl name='cl_mflags' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='384'>
	- <var-decl name='libzfs_desc_active' type-id='95e97e5e' visibility='default'/>
	+ <var-decl name='cl_gflags' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='416'>
	- <var-decl name='libzfs_action' type-id='b54ce520' visibility='default'/>
	+ <var-decl name='cl_haszonedchild' type-id='c19b74c3' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='8608'>
	- <var-decl name='libzfs_desc' type-id='b54ce520' visibility='default'/>
	+ </class-decl>
	+ <union-decl name='pthread_mutex_t' size-in-bits='320' naming-typedef-id='7a6844eb' visibility='default' id='70681f9b'>
	+ <data-member access='public'>
	+ <var-decl name='__data' type-id='4c734837' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='16800'>
	- <var-decl name='libzfs_printerr' type-id='95e97e5e' visibility='default'/>
	+ <data-member access='public'>
	+ <var-decl name='__size' type-id='36c46961' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='16832'>
	- <var-decl name='libzfs_storeerr' type-id='95e97e5e' visibility='default'/>
	+ <data-member access='public'>
	+ <var-decl name='__align' type-id='bd54fe1a' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='16864'>
	- <var-decl name='libzfs_mnttab_enable' type-id='c19b74c3' visibility='default'/>
	+ </union-decl>
	+ <typedef-decl name='pthread_mutex_t' type-id='70681f9b' id='7a6844eb'/>
	+ <typedef-decl name='int32_t' type-id='33f57a65' id='3ff5601b'/>
	+ <typedef-decl name='uint8_t' type-id='c51d6389' id='b96825af'/>
	+ <typedef-decl name='uint32_t' type-id='62f1140c' id='8f92235e'/>
	+ <typedef-decl name='uint64_t' type-id='8910171f' id='9c313c2d'/>
	+ <class-decl name='__pthread_mutex_s' size-in-bits='320' is-struct='yes' visibility='default' id='4c734837'>
	+ <data-member access='public' layout-offset-in-bits='0'>
	+ <var-decl name='__lock' type-id='95e97e5e' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='16896'>
	- <var-decl name='libzfs_mnttab_cache_lock' type-id='7a6844eb' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='32'>
	+ <var-decl name='__count' type-id='f0981eeb' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='17216'>
	- <var-decl name='libzfs_mnttab_cache' type-id='f20fbd51' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='64'>
	+ <var-decl name='__owner' type-id='95e97e5e' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='17536'>
	- <var-decl name='libzfs_pool_iter' type-id='95e97e5e' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='96'>
	+ <var-decl name='__nusers' type-id='f0981eeb' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='17568'>
	- <var-decl name='libzfs_chassis_id' type-id='d1617432' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='128'>
	+ <var-decl name='__kind' type-id='95e97e5e' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='19616'>
	- <var-decl name='libzfs_prop_debug' type-id='c19b74c3' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='160'>
	+ <var-decl name='__spins' type-id='a2185560' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='19648'>
	- <var-decl name='libzfs_urire' type-id='aca3bac8' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='176'>
	+ <var-decl name='__elision' type-id='a2185560' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='20160'>
	- <var-decl name='libzfs_max_nvlist' type-id='9c313c2d' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='192'>
	+ <var-decl name='__list' type-id='518fb49c' visibility='default'/>
	+ </data-member>
	+ </class-decl>
	+ <class-decl name='__pthread_internal_list' size-in-bits='128' is-struct='yes' visibility='default' id='0e01899c'>
	+ <data-member access='public' layout-offset-in-bits='0'>
	+ <var-decl name='__prev' type-id='4d98cd5a' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='64'>
	+ <var-decl name='__next' type-id='4d98cd5a' visibility='default'/>
	</data-member>
	</class-decl>
	+ <typedef-decl name='__pthread_list_t' type-id='0e01899c' id='518fb49c'/>
	+ <typedef-decl name='__uint8_t' type-id='002ac4a6' id='c51d6389'/>
	+ <typedef-decl name='__int32_t' type-id='95e97e5e' id='33f57a65'/>
	+ <typedef-decl name='__uint32_t' type-id='f0981eeb' id='62f1140c'/>
	+ <typedef-decl name='__uint64_t' type-id='7359adad' id='8910171f'/>
	+ <typedef-decl name='__off_t' type-id='bd54fe1a' id='79989e9c'/>
	+ <typedef-decl name='__off64_t' type-id='bd54fe1a' id='724e4de6'/>
	<typedef-decl name='FILE' type-id='ec1ed955' id='aa12d1ba'/>
	+ <typedef-decl name='_IO_lock_t' type-id='48b5725f' id='bb4788fa'/>
	<class-decl name='_IO_FILE' size-in-bits='1728' is-struct='yes' visibility='default' id='ec1ed955'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='_flags' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='_IO_read_ptr' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='_IO_read_end' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	<var-decl name='_IO_read_base' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='256'>
	<var-decl name='_IO_write_base' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='320'>
	<var-decl name='_IO_write_ptr' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='384'>
	<var-decl name='_IO_write_end' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='448'>
	<var-decl name='_IO_buf_base' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='512'>
	<var-decl name='_IO_buf_end' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='576'>
	<var-decl name='_IO_save_base' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='640'>
	<var-decl name='_IO_backup_base' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='704'>
	<var-decl name='_IO_save_end' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='768'>
	<var-decl name='_markers' type-id='e4c6fa61' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='832'>
	<var-decl name='_chain' type-id='dca988a5' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='896'>
	<var-decl name='_fileno' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='928'>
	<var-decl name='_flags2' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='960'>
	<var-decl name='_old_offset' type-id='79989e9c' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='1024'>
	<var-decl name='_cur_column' type-id='8efea9e5' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='1040'>
	<var-decl name='_vtable_offset' type-id='28577a57' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='1048'>
	<var-decl name='_shortbuf' type-id='89feb1ec' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='1088'>
	<var-decl name='_lock' type-id='cecf4ea7' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='1152'>
	<var-decl name='_offset' type-id='724e4de6' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='1216'>
	- <var-decl name='__pad1' type-id='eaa32e2f' visibility='default'/>
	+ <var-decl name='_codecvt' type-id='570f8c59' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='1280'>
	- <var-decl name='__pad2' type-id='eaa32e2f' visibility='default'/>
	+ <var-decl name='_wide_data' type-id='c65a1f29' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='1344'>
	- <var-decl name='__pad3' type-id='eaa32e2f' visibility='default'/>
	+ <var-decl name='_freeres_list' type-id='dca988a5' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='1408'>
	- <var-decl name='__pad4' type-id='eaa32e2f' visibility='default'/>
	+ <var-decl name='_freeres_buf' type-id='eaa32e2f' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='1472'>
	<var-decl name='__pad5' type-id='b59d7dce' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='1536'>
	<var-decl name='_mode' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='1568'>
	<var-decl name='_unused2' type-id='664ac0b7' visibility='default'/>
	</data-member>
	</class-decl>
	- <class-decl name='_IO_marker' size-in-bits='192' is-struct='yes' visibility='default' id='010ae0b9'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='_next' type-id='e4c6fa61' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='_sbuf' type-id='dca988a5' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='_pos' type-id='95e97e5e' visibility='default'/>
	- </data-member>
	- </class-decl>
	- <typedef-decl name='__off_t' type-id='bd54fe1a' id='79989e9c'/>
	- <typedef-decl name='_IO_lock_t' type-id='48b5725f' id='bb4788fa'/>
	- <typedef-decl name='__off64_t' type-id='bd54fe1a' id='724e4de6'/>
	- <typedef-decl name='size_t' type-id='7359adad' id='b59d7dce'/>
	- <class-decl name='zpool_handle' size-in-bits='2560' is-struct='yes' visibility='default' id='67002a8a'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='zpool_hdl' type-id='b0382bb3' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='zpool_next' type-id='4c81de99' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='zpool_name' type-id='d1617432' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='2176'>
	- <var-decl name='zpool_state' type-id='95e97e5e' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='2240'>
	- <var-decl name='zpool_config_size' type-id='b59d7dce' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='2304'>
	- <var-decl name='zpool_config' type-id='5ce45b60' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='2368'>
	- <var-decl name='zpool_old_config' type-id='5ce45b60' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='2432'>
	- <var-decl name='zpool_props' type-id='5ce45b60' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='2496'>
	- <var-decl name='zpool_start_block' type-id='804dc465' visibility='default'/>
	- </data-member>
	- </class-decl>
	- <typedef-decl name='libzfs_handle_t' type-id='c8a9d9d8' id='95942d0c'/>
	- <typedef-decl name='zpool_handle_t' type-id='67002a8a' id='b1efc708'/>
	- <typedef-decl name='nvlist_t' type-id='ac266fd9' id='8e8d4be3'/>
	- <class-decl name='nvlist' size-in-bits='192' is-struct='yes' visibility='default' id='ac266fd9'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='nvl_version' type-id='3ff5601b' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='32'>
	- <var-decl name='nvl_nvflag' type-id='8f92235e' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='nvl_priv' type-id='9c313c2d' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='nvl_flag' type-id='8f92235e' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='160'>
	- <var-decl name='nvl_pad' type-id='3ff5601b' visibility='default'/>
	- </data-member>
	- </class-decl>
	- <typedef-decl name='int32_t' type-id='95e97e5e' id='3ff5601b'/>
	- <typedef-decl name='uint32_t' type-id='f0981eeb' id='8f92235e'/>
	- <typedef-decl name='uint64_t' type-id='7359adad' id='9c313c2d'/>
	- <typedef-decl name='diskaddr_t' type-id='9b3ff54f' id='804dc465'/>
	- <typedef-decl name='longlong_t' type-id='1eb56b1e' id='9b3ff54f'/>
	- <typedef-decl name='pthread_mutex_t' type-id='c4794498' id='7a6844eb'/>
	- <union-decl name='__anonymous_union__' size-in-bits='320' is-anonymous='yes' visibility='default' id='c4794498'>
	- <data-member access='private'>
	- <var-decl name='__data' type-id='4c734837' visibility='default'/>
	- </data-member>
	- <data-member access='private'>
	- <var-decl name='__size' type-id='36c46961' visibility='default'/>
	- </data-member>
	- <data-member access='private'>
	- <var-decl name='__align' type-id='bd54fe1a' visibility='default'/>
	- </data-member>
	- </union-decl>
	- <class-decl name='__pthread_mutex_s' size-in-bits='320' is-struct='yes' visibility='default' id='4c734837'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='__lock' type-id='95e97e5e' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='32'>
	- <var-decl name='__count' type-id='f0981eeb' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='__owner' type-id='95e97e5e' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='96'>
	- <var-decl name='__nusers' type-id='f0981eeb' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='__kind' type-id='95e97e5e' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='160'>
	- <var-decl name='__spins' type-id='a2185560' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='176'>
	- <var-decl name='__elision' type-id='a2185560' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='192'>
	- <var-decl name='__list' type-id='518fb49c' visibility='default'/>
	- </data-member>
	- </class-decl>
	- <typedef-decl name='__pthread_list_t' type-id='0e01899c' id='518fb49c'/>
	- <class-decl name='__pthread_internal_list' size-in-bits='128' is-struct='yes' visibility='default' id='0e01899c'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='__prev' type-id='4d98cd5a' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='__next' type-id='4d98cd5a' visibility='default'/>
	- </data-member>
	- </class-decl>
	- <typedef-decl name='avl_tree_t' type-id='b351119f' id='f20fbd51'/>
	- <class-decl name='avl_tree' size-in-bits='320' is-struct='yes' visibility='default' id='b351119f'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='avl_root' type-id='bf311473' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='avl_compar' type-id='585e1de9' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='avl_offset' type-id='b59d7dce' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='192'>
	- <var-decl name='avl_numnodes' type-id='ee1f298e' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='256'>
	- <var-decl name='avl_size' type-id='b59d7dce' visibility='default'/>
	- </data-member>
	- </class-decl>
	- <class-decl name='avl_node' size-in-bits='192' is-struct='yes' visibility='default' id='428b67b3'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='avl_child' type-id='f0f65199' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='avl_pcb' type-id='e475ab95' visibility='default'/>
	- </data-member>
	- </class-decl>
	- <typedef-decl name='uintptr_t' type-id='7359adad' id='e475ab95'/>
	- <typedef-decl name='ulong_t' type-id='7359adad' id='ee1f298e'/>
	- <typedef-decl name='regex_t' type-id='19fc9a8c' id='aca3bac8'/>
	+ <typedef-decl name='__re_long_size_t' type-id='7359adad' id='ba516949'/>
	+ <typedef-decl name='reg_syntax_t' type-id='7359adad' id='1b72c3b3'/>
	<class-decl name='re_pattern_buffer' size-in-bits='512' is-struct='yes' visibility='default' id='19fc9a8c'>
	<data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='buffer' type-id='cf536864' visibility='default'/>
	+ <var-decl name='buffer' type-id='33976309' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='allocated' type-id='7359adad' visibility='default'/>
	+ <var-decl name='allocated' type-id='ba516949' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='used' type-id='7359adad' visibility='default'/>
	+ <var-decl name='used' type-id='ba516949' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	<var-decl name='syntax' type-id='1b72c3b3' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='256'>
	<var-decl name='fastmap' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='320'>
	<var-decl name='translate' type-id='cf536864' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='384'>
	<var-decl name='re_nsub' type-id='b59d7dce' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='31'>
	+ <data-member access='public' layout-offset-in-bits='448'>
	<var-decl name='can_be_null' type-id='f0981eeb' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='29'>
	+ <data-member access='public' layout-offset-in-bits='449'>
	<var-decl name='regs_allocated' type-id='f0981eeb' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='28'>
	+ <data-member access='public' layout-offset-in-bits='451'>
	<var-decl name='fastmap_accurate' type-id='f0981eeb' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='27'>
	+ <data-member access='public' layout-offset-in-bits='452'>
	<var-decl name='no_sub' type-id='f0981eeb' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='26'>
	+ <data-member access='public' layout-offset-in-bits='453'>
	<var-decl name='not_bol' type-id='f0981eeb' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='25'>
	+ <data-member access='public' layout-offset-in-bits='454'>
	<var-decl name='not_eol' type-id='f0981eeb' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='24'>
	+ <data-member access='public' layout-offset-in-bits='455'>
	<var-decl name='newline_anchor' type-id='f0981eeb' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='reg_syntax_t' type-id='7359adad' id='1b72c3b3'/>
	- <typedef-decl name='zfs_type_t' type-id='3eed36ad' id='2e45de5d'/>
	- <enum-decl name='__anonymous_enum__3' is-anonymous='yes' id='3eed36ad'>
	- <underlying-type type-id='9cac1fee'/>
	- <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='dmu_objset_stats_t' type-id='098f0221' id='b2c14f17'/>
	- <class-decl name='dmu_objset_stats' size-in-bits='2304' is-struct='yes' visibility='default' id='098f0221'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='dds_num_clones' type-id='9c313c2d' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='dds_creation_txg' type-id='9c313c2d' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='dds_guid' type-id='9c313c2d' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='192'>
	- <var-decl name='dds_type' type-id='230f1e16' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='224'>
	- <var-decl name='dds_is_snapshot' type-id='b96825af' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='232'>
	- <var-decl name='dds_inconsistent' type-id='b96825af' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='240'>
	- <var-decl name='dds_redacted' type-id='b96825af' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='248'>
	- <var-decl name='dds_origin' type-id='d1617432' visibility='default'/>
	- </data-member>
	- </class-decl>
	- <typedef-decl name='dmu_objset_type_t' type-id='6b1b19f9' id='230f1e16'/>
	- <enum-decl name='dmu_objset_type' id='6b1b19f9'>
	- <underlying-type type-id='9cac1fee'/>
	- <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='uint8_t' type-id='002ac4a6' id='b96825af'/>
	- <typedef-decl name='zprop_source_t' type-id='3ded3519' id='a2256d42'/>
	- <enum-decl name='__anonymous_enum__4' is-anonymous='yes' id='3ded3519'>
	- <underlying-type type-id='9cac1fee'/>
	- <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='zoneid_t' type-id='95e97e5e' id='4da03624'/>
	- <typedef-decl name='uu_avl_node_t' type-id='f65f4326' id='73a65116'/>
	- <class-decl name='uu_avl_node' size-in-bits='192' is-struct='yes' visibility='default' id='f65f4326'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='uan_opaque' type-id='0ce65a8b' visibility='default'/>
	- </data-member>
	- </class-decl>
	- <typedef-decl name='uu_avl_index_t' type-id='e475ab95' id='5d7f5fc8'/>
	- <typedef-decl name='zfs_iter_f' type-id='5571cde4' id='d8e49ab9'/>
	- <typedef-decl name='uu_avl_walk_t' type-id='e70a39e3' id='edd8457b'/>
	- <typedef-decl name='uu_compare_fn_t' type-id='add6e811' id='40f93560'/>
	+ <typedef-decl name='regex_t' type-id='19fc9a8c' id='aca3bac8'/>
	+ <typedef-decl name='uintptr_t' type-id='7359adad' id='e475ab95'/>
	+ <typedef-decl name='size_t' type-id='7359adad' id='b59d7dce'/>
	<pointer-type-def type-id='aa12d1ba' size-in-bits='64' id='822cd80b'/>
	<pointer-type-def type-id='ec1ed955' size-in-bits='64' id='dca988a5'/>
	+ <pointer-type-def type-id='a4036571' size-in-bits='64' id='570f8c59'/>
	<pointer-type-def type-id='bb4788fa' size-in-bits='64' id='cecf4ea7'/>
	<pointer-type-def type-id='010ae0b9' size-in-bits='64' id='e4c6fa61'/>
	+ <pointer-type-def type-id='79bd3751' size-in-bits='64' id='c65a1f29'/>
	<pointer-type-def type-id='0e01899c' size-in-bits='64' id='4d98cd5a'/>
	<pointer-type-def type-id='428b67b3' size-in-bits='64' id='bf311473'/>
	<pointer-type-def type-id='a84c031d' size-in-bits='64' id='26a90f95'/>
	<pointer-type-def type-id='26a90f95' size-in-bits='64' id='9b23c9ad'/>
	<qualified-type-def type-id='a84c031d' const='yes' id='9b45d938'/>
	<pointer-type-def type-id='9b45d938' size-in-bits='64' id='80f4b756'/>
	<qualified-type-def type-id='775509eb' const='yes' id='5eadf2db'/>
	<pointer-type-def type-id='5eadf2db' size-in-bits='64' id='fcd57163'/>
	<pointer-type-def type-id='96ee24a5' size-in-bits='64' id='585e1de9'/>
	<pointer-type-def type-id='cb9628fa' size-in-bits='64' id='5571cde4'/>
	<pointer-type-def type-id='95942d0c' size-in-bits='64' id='b0382bb3'/>
	<pointer-type-def type-id='8e8d4be3' size-in-bits='64' id='5ce45b60'/>
	<pointer-type-def type-id='eae6431d' size-in-bits='64' id='0d41d328'/>
	+ <pointer-type-def type-id='b48d2441' size-in-bits='64' id='33976309'/>
	<pointer-type-def type-id='b96825af' size-in-bits='64' id='ae3e8ca6'/>
	<pointer-type-def type-id='002ac4a6' size-in-bits='64' id='cf536864'/>
	<pointer-type-def type-id='5d7f5fc8' size-in-bits='64' id='813a2225'/>
	<pointer-type-def type-id='73a65116' size-in-bits='64' id='2dc35b9d'/>
	<pointer-type-def type-id='7f84e390' size-in-bits='64' id='de82c773'/>
	<pointer-type-def type-id='bb7f0973' size-in-bits='64' id='a5c21a38'/>
	<pointer-type-def type-id='edd8457b' size-in-bits='64' id='5842d146'/>
	<pointer-type-def type-id='40f93560' size-in-bits='64' id='d502b39f'/>
	<pointer-type-def type-id='48b5725f' size-in-bits='64' id='eaa32e2f'/>
	<pointer-type-def type-id='775509eb' size-in-bits='64' id='9200a744'/>
	<pointer-type-def type-id='a7913f77' size-in-bits='64' id='bf9c30ee'/>
	<pointer-type-def type-id='b1efc708' size-in-bits='64' id='4c81de99'/>
	<pointer-type-def type-id='a2256d42' size-in-bits='64' id='debc6aa3'/>
	- <function-decl name='changelist_postfix' mangled-name='changelist_postfix' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='changelist_postfix'>
	- <parameter type-id='0d41d328' name='clp'/>
	- <return type-id='95e97e5e'/>
	+ <class-decl name='_IO_codecvt' is-struct='yes' visibility='default' is-declaration-only='yes' id='a4036571'/>
	+ <class-decl name='_IO_marker' is-struct='yes' visibility='default' is-declaration-only='yes' id='010ae0b9'/>
	+ <class-decl name='_IO_wide_data' is-struct='yes' visibility='default' is-declaration-only='yes' id='79bd3751'/>
	+ <class-decl name='re_dfa_t' is-struct='yes' visibility='default' is-declaration-only='yes' id='b48d2441'/>
	+ <class-decl name='uu_avl' is-struct='yes' visibility='default' is-declaration-only='yes' id='4af029d1'/>
	+ <class-decl name='uu_avl_pool' is-struct='yes' visibility='default' is-declaration-only='yes' id='12a530a8'/>
	+ <class-decl name='uu_avl_walk' is-struct='yes' visibility='default' is-declaration-only='yes' id='e70a39e3'/>
	+ <function-decl name='uu_avl_pool_create' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='b59d7dce'/>
	+ <parameter type-id='b59d7dce'/>
	+ <parameter type-id='d502b39f'/>
	+ <parameter type-id='8f92235e'/>
	+ <return type-id='de82c773'/>
	</function-decl>
	- <function-decl name='changelist_prefix' mangled-name='changelist_prefix' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='changelist_prefix'>
	- <parameter type-id='0d41d328' name='clp'/>
	- <return type-id='95e97e5e'/>
	+ <function-decl name='uu_avl_pool_destroy' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='de82c773'/>
	+ <return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='isa_child_of' mangled-name='isa_child_of' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='isa_child_of'>
	- <parameter type-id='80f4b756' name='dataset'/>
	- <parameter type-id='80f4b756' name='parent'/>
	- <return type-id='c19b74c3'/>
	+ <function-decl name='uu_avl_node_init' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='eaa32e2f'/>
	+ <parameter type-id='2dc35b9d'/>
	+ <parameter type-id='de82c773'/>
	+ <return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='changelist_rename' mangled-name='changelist_rename' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='changelist_rename'>
	- <parameter type-id='0d41d328' name='clp'/>
	- <parameter type-id='80f4b756' name='src'/>
	- <parameter type-id='80f4b756' name='dst'/>
	+ <function-decl name='uu_avl_create' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='de82c773'/>
	+ <parameter type-id='eaa32e2f'/>
	+ <parameter type-id='8f92235e'/>
	+ <return type-id='a5c21a38'/>
	+ </function-decl>
	+ <function-decl name='uu_avl_destroy' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='a5c21a38'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='changelist_unshare' mangled-name='changelist_unshare' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='changelist_unshare'>
	- <parameter type-id='0d41d328' name='clp'/>
	- <parameter type-id='bf9c30ee' name='proto'/>
	- <return type-id='95e97e5e'/>
	+ <function-decl name='uu_avl_last' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='a5c21a38'/>
	+ <return type-id='eaa32e2f'/>
	</function-decl>
	- <function-decl name='changelist_haszonedchild' mangled-name='changelist_haszonedchild' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='changelist_haszonedchild'>
	- <parameter type-id='0d41d328' name='clp'/>
	- <return type-id='95e97e5e'/>
	+ <function-decl name='uu_avl_walk_start' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='a5c21a38'/>
	+ <parameter type-id='8f92235e'/>
	+ <return type-id='5842d146'/>
	</function-decl>
	- <function-decl name='changelist_remove' mangled-name='changelist_remove' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='changelist_remove'>
	- <parameter type-id='0d41d328' name='clp'/>
	- <parameter type-id='80f4b756' name='name'/>
	+ <function-decl name='uu_avl_walk_next' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='5842d146'/>
	+ <return type-id='eaa32e2f'/>
	+ </function-decl>
	+ <function-decl name='uu_avl_walk_end' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='5842d146'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='changelist_free' mangled-name='changelist_free' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='changelist_free'>
	- <parameter type-id='0d41d328' name='clp'/>
	+ <function-decl name='uu_avl_find' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='a5c21a38'/>
	+ <parameter type-id='eaa32e2f'/>
	+ <parameter type-id='eaa32e2f'/>
	+ <parameter type-id='813a2225'/>
	+ <return type-id='eaa32e2f'/>
	+ </function-decl>
	+ <function-decl name='uu_avl_insert' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='a5c21a38'/>
	+ <parameter type-id='eaa32e2f'/>
	+ <parameter type-id='5d7f5fc8'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='changelist_gather' mangled-name='changelist_gather' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='changelist_gather'>
	- <parameter type-id='9200a744' name='zhp'/>
	- <parameter type-id='58603c44' name='prop'/>
	- <parameter type-id='95e97e5e' name='gather_flags'/>
	- <parameter type-id='95e97e5e' name='mnt_flags'/>
	- <return type-id='0d41d328'/>
	+ <function-decl name='uu_avl_remove' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='a5c21a38'/>
	+ <parameter type-id='eaa32e2f'/>
	+ <return type-id='48b5725f'/>
	+ </function-decl>
	+ <function-decl name='zfs_get_handle' mangled-name='zfs_get_handle' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_get_handle'>
	+ <parameter type-id='9200a744'/>
	+ <return type-id='b0382bb3'/>
	+ </function-decl>
	+ <function-decl name='zfs_open' mangled-name='zfs_open' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_open'>
	+ <parameter type-id='b0382bb3'/>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='95e97e5e'/>
	+ <return type-id='9200a744'/>
	+ </function-decl>
	+ <function-decl name='zfs_close' mangled-name='zfs_close' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_close'>
	+ <parameter type-id='9200a744'/>
	+ <return type-id='48b5725f'/>
	+ </function-decl>
	+ <function-decl name='zfs_get_name' mangled-name='zfs_get_name' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_get_name'>
	+ <parameter type-id='fcd57163'/>
	+ <return type-id='80f4b756'/>
	</function-decl>
	<function-decl name='zfs_prop_get' mangled-name='zfs_prop_get' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_get'>
	<parameter type-id='9200a744'/>
	<parameter type-id='58603c44'/>
	<parameter type-id='26a90f95'/>
	<parameter type-id='b59d7dce'/>
	<parameter type-id='debc6aa3'/>
	<parameter type-id='26a90f95'/>
	<parameter type-id='b59d7dce'/>
	<parameter type-id='c19b74c3'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zfs_get_handle' mangled-name='zfs_get_handle' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_get_handle'>
	- <parameter type-id='9200a744'/>
	- <return type-id='b0382bb3'/>
	- </function-decl>
	- <function-decl name='zfs_alloc' mangled-name='zfs_alloc' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_alloc'>
	- <parameter type-id='b0382bb3'/>
	- <parameter type-id='b59d7dce'/>
	- <return type-id='eaa32e2f'/>
	- </function-decl>
	- <function-decl name='zfs_is_shared' mangled-name='zfs_is_shared' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_is_shared'>
	- <parameter type-id='9200a744'/>
	- <return type-id='c19b74c3'/>
	- </function-decl>
	<function-decl name='zfs_prop_get_int' mangled-name='zfs_prop_get_int' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_get_int'>
	<parameter type-id='9200a744'/>
	<parameter type-id='58603c44'/>
	<return type-id='9c313c2d'/>
	</function-decl>
	- <function-decl name='getzoneid' visibility='default' binding='global' size-in-bits='64'>
	- <return type-id='4da03624'/>
	- </function-decl>
	- <function-decl name='uu_avl_node_init' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='eaa32e2f'/>
	- <parameter type-id='2dc35b9d'/>
	- <parameter type-id='de82c773'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	- <function-decl name='uu_avl_find' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='a5c21a38'/>
	- <parameter type-id='eaa32e2f'/>
	- <parameter type-id='eaa32e2f'/>
	- <parameter type-id='813a2225'/>
	- <return type-id='eaa32e2f'/>
	- </function-decl>
	- <function-decl name='free' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='eaa32e2f'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	- <function-decl name='zfs_is_mounted' mangled-name='zfs_is_mounted' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_is_mounted'>
	- <parameter type-id='9200a744'/>
	- <parameter type-id='9b23c9ad'/>
	- <return type-id='c19b74c3'/>
	- </function-decl>
	<function-decl name='zfs_iter_children' mangled-name='zfs_iter_children' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_iter_children'>
	<parameter type-id='9200a744'/>
	<parameter type-id='d8e49ab9'/>
	<parameter type-id='eaa32e2f'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='uu_avl_insert' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='a5c21a38'/>
	+ <function-decl name='zfs_iter_dependents' mangled-name='zfs_iter_dependents' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_iter_dependents'>
	+ <parameter type-id='9200a744'/>
	+ <parameter type-id='c19b74c3'/>
	+ <parameter type-id='d8e49ab9'/>
	<parameter type-id='eaa32e2f'/>
	- <parameter type-id='5d7f5fc8'/>
	- <return type-id='48b5725f'/>
	+ <return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zfs_close' mangled-name='zfs_close' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_close'>
	+ <function-decl name='zfs_iter_mounted' mangled-name='zfs_iter_mounted' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_iter_mounted'>
	<parameter type-id='9200a744'/>
	- <return type-id='48b5725f'/>
	+ <parameter type-id='d8e49ab9'/>
	+ <parameter type-id='eaa32e2f'/>
	+ <return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='zfs_refresh_properties' mangled-name='zfs_refresh_properties' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_refresh_properties'>
	<parameter type-id='9200a744'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='zfs_unshare_nfs' mangled-name='zfs_unshare_nfs' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_unshare_nfs'>
	+ <function-decl name='zfs_is_mounted' mangled-name='zfs_is_mounted' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_is_mounted'>
	<parameter type-id='9200a744'/>
	- <parameter type-id='80f4b756'/>
	- <return type-id='95e97e5e'/>
	+ <parameter type-id='9b23c9ad'/>
	+ <return type-id='c19b74c3'/>
	</function-decl>
	- <function-decl name='zfs_unshare_smb' mangled-name='zfs_unshare_smb' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_unshare_smb'>
	+ <function-decl name='zfs_mount' mangled-name='zfs_mount' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_mount'>
	<parameter type-id='9200a744'/>
	<parameter type-id='80f4b756'/>
	+ <parameter type-id='95e97e5e'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zfs_mount' mangled-name='zfs_mount' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_mount'>
	+ <function-decl name='zfs_unmount' mangled-name='zfs_unmount' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_unmount'>
	<parameter type-id='9200a744'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='95e97e5e'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	+ <function-decl name='zfs_is_shared' mangled-name='zfs_is_shared' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_is_shared'>
	+ <parameter type-id='9200a744'/>
	+ <return type-id='c19b74c3'/>
	+ </function-decl>
	<function-decl name='zfs_share_nfs' mangled-name='zfs_share_nfs' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_share_nfs'>
	<parameter type-id='9200a744'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='zfs_share_smb' mangled-name='zfs_share_smb' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_share_smb'>
	<parameter type-id='9200a744'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='uu_avl_last' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='a5c21a38'/>
	- <return type-id='eaa32e2f'/>
	+ <function-decl name='zfs_unshare_nfs' mangled-name='zfs_unshare_nfs' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_unshare_nfs'>
	+ <parameter type-id='9200a744'/>
	+ <parameter type-id='80f4b756'/>
	+ <return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='uu_avl_walk_start' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='a5c21a38'/>
	- <parameter type-id='8f92235e'/>
	- <return type-id='5842d146'/>
	- </function-decl>
	- <function-decl name='uu_avl_walk_next' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='5842d146'/>
	- <return type-id='eaa32e2f'/>
	- </function-decl>
	- <function-decl name='uu_avl_walk_end' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='5842d146'/>
	- <return type-id='48b5725f'/>
	+ <function-decl name='zfs_unshare_smb' mangled-name='zfs_unshare_smb' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_unshare_smb'>
	+ <parameter type-id='9200a744'/>
	+ <parameter type-id='80f4b756'/>
	+ <return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='zfs_commit_nfs_shares' mangled-name='zfs_commit_nfs_shares' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_commit_nfs_shares'>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='zfs_commit_smb_shares' mangled-name='zfs_commit_smb_shares' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_commit_smb_shares'>
	<return type-id='48b5725f'/>
	</function-decl>
	+ <function-decl name='zfs_error' mangled-name='zfs_error' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_error'>
	+ <parameter type-id='b0382bb3'/>
	+ <parameter type-id='95e97e5e'/>
	+ <parameter type-id='80f4b756'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='zfs_alloc' mangled-name='zfs_alloc' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_alloc'>
	+ <parameter type-id='b0382bb3'/>
	+ <parameter type-id='b59d7dce'/>
	+ <return type-id='eaa32e2f'/>
	+ </function-decl>
	<function-decl name='remove_mountpoint' mangled-name='remove_mountpoint' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='remove_mountpoint'>
	<parameter type-id='9200a744'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='zfs_unmount' mangled-name='zfs_unmount' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_unmount'>
	+ <function-decl name='zfs_unshare_proto' mangled-name='zfs_unshare_proto' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_unshare_proto'>
	<parameter type-id='9200a744'/>
	<parameter type-id='80f4b756'/>
	- <parameter type-id='95e97e5e'/>
	+ <parameter type-id='bf9c30ee'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='strlen' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='80f4b756'/>
	- <return type-id='b59d7dce'/>
	+ <function-decl name='zfs_commit_proto' mangled-name='zfs_commit_proto' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_commit_proto'>
	+ <parameter type-id='bf9c30ee'/>
	+ <return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='strncmp' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='b59d7dce'/>
	- <return type-id='95e97e5e'/>
	+ <function-decl name='getzoneid' visibility='default' binding='global' size-in-bits='64'>
	+ <return type-id='4da03624'/>
	</function-decl>
	- <function-decl name='strlcpy' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='strlcat' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='26a90f95'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='b59d7dce'/>
	<return type-id='b59d7dce'/>
	</function-decl>
	- <function-decl name='strlcat' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='strlcpy' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='26a90f95'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='b59d7dce'/>
	<return type-id='b59d7dce'/>
	</function-decl>
	- <function-decl name='zfs_unshare_proto' mangled-name='zfs_unshare_proto' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_unshare_proto'>
	- <parameter type-id='9200a744'/>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='bf9c30ee'/>
	+ <function-decl name='changelist_prefix' mangled-name='changelist_prefix' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='changelist_prefix'>
	+ <parameter type-id='0d41d328' name='clp'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zfs_commit_proto' mangled-name='zfs_commit_proto' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_commit_proto'>
	- <parameter type-id='bf9c30ee'/>
	- <return type-id='48b5725f'/>
	+ <function-decl name='changelist_postfix' mangled-name='changelist_postfix' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='changelist_postfix'>
	+ <parameter type-id='0d41d328' name='clp'/>
	+ <return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='uu_avl_remove' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='a5c21a38'/>
	- <parameter type-id='eaa32e2f'/>
	+ <function-decl name='isa_child_of' mangled-name='isa_child_of' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='isa_child_of'>
	+ <parameter type-id='80f4b756' name='dataset'/>
	+ <parameter type-id='80f4b756' name='parent'/>
	+ <return type-id='c19b74c3'/>
	+ </function-decl>
	+ <function-decl name='changelist_rename' mangled-name='changelist_rename' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='changelist_rename'>
	+ <parameter type-id='0d41d328' name='clp'/>
	+ <parameter type-id='80f4b756' name='src'/>
	+ <parameter type-id='80f4b756' name='dst'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='uu_avl_destroy' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='a5c21a38'/>
	+ <function-decl name='changelist_unshare' mangled-name='changelist_unshare' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='changelist_unshare'>
	+ <parameter type-id='0d41d328' name='clp'/>
	+ <parameter type-id='bf9c30ee' name='proto'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='changelist_haszonedchild' mangled-name='changelist_haszonedchild' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='changelist_haszonedchild'>
	+ <parameter type-id='0d41d328' name='clp'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='changelist_remove' mangled-name='changelist_remove' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='changelist_remove'>
	+ <parameter type-id='0d41d328' name='clp'/>
	+ <parameter type-id='80f4b756' name='name'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='uu_avl_pool_destroy' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='de82c773'/>
	+ <function-decl name='changelist_free' mangled-name='changelist_free' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='changelist_free'>
	+ <parameter type-id='0d41d328' name='clp'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='uu_avl_pool_create' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='b59d7dce'/>
	- <parameter type-id='b59d7dce'/>
	- <parameter type-id='d502b39f'/>
	- <parameter type-id='8f92235e'/>
	- <return type-id='de82c773'/>
	+ <function-decl name='changelist_gather' mangled-name='changelist_gather' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='changelist_gather'>
	+ <parameter type-id='9200a744' name='zhp'/>
	+ <parameter type-id='58603c44' name='prop'/>
	+ <parameter type-id='95e97e5e' name='gather_flags'/>
	+ <parameter type-id='95e97e5e' name='mnt_flags'/>
	+ <return type-id='0d41d328'/>
	</function-decl>
	- <function-decl name='uu_avl_create' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='de82c773'/>
	+ <function-decl name='free' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='eaa32e2f'/>
	- <parameter type-id='8f92235e'/>
	- <return type-id='a5c21a38'/>
	+ <return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='zfs_iter_dependents' mangled-name='zfs_iter_dependents' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_iter_dependents'>
	- <parameter type-id='9200a744'/>
	- <parameter type-id='c19b74c3'/>
	- <parameter type-id='d8e49ab9'/>
	- <parameter type-id='eaa32e2f'/>
	+ <function-decl name='strcmp' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='80f4b756'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zfs_get_name' mangled-name='zfs_get_name' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_get_name'>
	- <parameter type-id='fcd57163'/>
	- <return type-id='80f4b756'/>
	- </function-decl>
	- <function-decl name='zfs_open' mangled-name='zfs_open' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_open'>
	- <parameter type-id='b0382bb3'/>
	+ <function-decl name='strncmp' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='80f4b756'/>
	- <parameter type-id='95e97e5e'/>
	- <return type-id='9200a744'/>
	- </function-decl>
	- <function-decl name='zfs_iter_mounted' mangled-name='zfs_iter_mounted' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_iter_mounted'>
	- <parameter type-id='9200a744'/>
	- <parameter type-id='d8e49ab9'/>
	- <parameter type-id='eaa32e2f'/>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='b59d7dce'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zfs_error' mangled-name='zfs_error' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_error'>
	- <parameter type-id='b0382bb3'/>
	- <parameter type-id='95e97e5e'/>
	+ <function-decl name='strlen' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='80f4b756'/>
	- <return type-id='95e97e5e'/>
	+ <return type-id='b59d7dce'/>
	</function-decl>
	<function-type size-in-bits='64' id='96ee24a5'>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='eaa32e2f'/>
	<return type-id='95e97e5e'/>
	</function-type>
	<function-type size-in-bits='64' id='add6e811'>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='eaa32e2f'/>
	<return type-id='95e97e5e'/>
	</function-type>
	<function-type size-in-bits='64' id='cb9628fa'>
	<parameter type-id='9200a744'/>
	<parameter type-id='eaa32e2f'/>
	<return type-id='95e97e5e'/>
	</function-type>
	</abi-instr>
	- <abi-instr version='1.0' address-size='64' path='libzfs_config.c' language='LANG_C89'>
	+ <abi-instr address-size='64' path='libzfs_config.c' language='LANG_C99'>
	<array-type-def dimensions='1' type-id='a84c031d' size-in-bits='32768' id='d16c6df4'>
	- <subrange length='4096' type-id='4c87fef4' id='bc1b5ddc'/>
	+ <subrange length='4096' type-id='7359adad' id='bc1b5ddc'/>
	</array-type-def>
	<array-type-def dimensions='1' type-id='a84c031d' size-in-bits='65536' id='163f6aa5'>
	- <subrange length='8192' type-id='4c87fef4' id='c88f397d'/>
	+ <subrange length='8192' type-id='7359adad' id='c88f397d'/>
	</array-type-def>
	<array-type-def dimensions='1' type-id='9c313c2d' size-in-bits='128' id='c1c22e6c'>
	- <subrange length='2' type-id='4c87fef4' id='52efc4ef'/>
	+ <subrange length='2' type-id='7359adad' id='52efc4ef'/>
	</array-type-def>
	<array-type-def dimensions='1' type-id='b96825af' size-in-bits='24' id='d3490169'>
	- <subrange length='3' type-id='4c87fef4' id='56f209d2'/>
	+ <subrange length='3' type-id='7359adad' id='56f209d2'/>
	</array-type-def>
	<type-decl name='variadic parameter type' id='2c1145c5'/>
	<typedef-decl name='zpool_iter_f' type-id='3aebb66f' id='fa476e62'/>
	- <typedef-decl name='nvpair_t' type-id='1c34e459' id='57928edf'/>
	- <class-decl name='nvpair' size-in-bits='128' is-struct='yes' visibility='default' id='1c34e459'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='nvp_size' type-id='3ff5601b' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='32'>
	- <var-decl name='nvp_name_sz' type-id='23bd8cb5' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='48'>
	- <var-decl name='nvp_reserve' type-id='23bd8cb5' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='nvp_value_elem' type-id='3ff5601b' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='96'>
	- <var-decl name='nvp_type' type-id='8d0687d2' visibility='default'/>
	- </data-member>
	- </class-decl>
	- <typedef-decl name='int16_t' type-id='a2185560' id='23bd8cb5'/>
	- <typedef-decl name='data_type_t' type-id='08f5ca17' id='8d0687d2'/>
	- <enum-decl name='__anonymous_enum__' is-anonymous='yes' id='08f5ca17'>
	+ <enum-decl name='data_type_t' naming-typedef-id='8d0687d2' id='aeeae136'>
	<underlying-type type-id='9cac1fee'/>
	<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='zfs_cmd_t' type-id='3522cd69' id='a5559cdd'/>
	- <class-decl name='zfs_cmd' size-in-bits='109952' is-struct='yes' visibility='default' id='3522cd69'>
	+ <typedef-decl name='data_type_t' type-id='aeeae136' id='8d0687d2'/>
	+ <class-decl name='nvpair' size-in-bits='128' is-struct='yes' visibility='default' id='1c34e459'>
	<data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='zc_name' type-id='d16c6df4' visibility='default'/>
	+ <var-decl name='nvp_size' type-id='3ff5601b' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='32768'>
	- <var-decl name='zc_nvlist_src' type-id='9c313c2d' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='32'>
	+ <var-decl name='nvp_name_sz' type-id='23bd8cb5' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='32832'>
	- <var-decl name='zc_nvlist_src_size' type-id='9c313c2d' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='48'>
	+ <var-decl name='nvp_reserve' type-id='23bd8cb5' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='32896'>
	- <var-decl name='zc_nvlist_dst' type-id='9c313c2d' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='64'>
	+ <var-decl name='nvp_value_elem' type-id='3ff5601b' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='32960'>
	- <var-decl name='zc_nvlist_dst_size' type-id='9c313c2d' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='96'>
	+ <var-decl name='nvp_type' type-id='8d0687d2' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='33024'>
	- <var-decl name='zc_nvlist_dst_filled' type-id='c19b74c3' visibility='default'/>
	+ </class-decl>
	+ <typedef-decl name='nvpair_t' type-id='1c34e459' id='57928edf'/>
	+ <class-decl name='drr_begin' size-in-bits='2432' is-struct='yes' visibility='default' id='09fcdc01'>
	+ <data-member access='public' layout-offset-in-bits='0'>
	+ <var-decl name='drr_magic' type-id='9c313c2d' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='33056'>
	- <var-decl name='zc_pad2' type-id='95e97e5e' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='64'>
	+ <var-decl name='drr_versioninfo' type-id='9c313c2d' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='33088'>
	- <var-decl name='zc_history' type-id='9c313c2d' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='128'>
	+ <var-decl name='drr_creation_time' type-id='9c313c2d' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='33152'>
	- <var-decl name='zc_value' type-id='163f6aa5' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='192'>
	+ <var-decl name='drr_type' type-id='230f1e16' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='98688'>
	- <var-decl name='zc_string' type-id='d1617432' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='224'>
	+ <var-decl name='drr_flags' type-id='8f92235e' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='100736'>
	- <var-decl name='zc_guid' type-id='9c313c2d' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='256'>
	+ <var-decl name='drr_toguid' type-id='9c313c2d' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='100800'>
	- <var-decl name='zc_nvlist_conf' type-id='9c313c2d' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='320'>
	+ <var-decl name='drr_fromguid' type-id='9c313c2d' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='100864'>
	- <var-decl name='zc_nvlist_conf_size' type-id='9c313c2d' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='384'>
	+ <var-decl name='drr_toname' type-id='d1617432' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='100928'>
	- <var-decl name='zc_cookie' type-id='9c313c2d' visibility='default'/>
	+ </class-decl>
	+ <class-decl name='zinject_record' size-in-bits='2816' is-struct='yes' visibility='default' id='3216f820'>
	+ <data-member access='public' layout-offset-in-bits='0'>
	+ <var-decl name='zi_objset' type-id='9c313c2d' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='100992'>
	- <var-decl name='zc_objset_type' type-id='9c313c2d' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='64'>
	+ <var-decl name='zi_object' type-id='9c313c2d' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='101056'>
	- <var-decl name='zc_perm_action' type-id='9c313c2d' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='128'>
	+ <var-decl name='zi_start' type-id='9c313c2d' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='101120'>
	- <var-decl name='zc_history_len' type-id='9c313c2d' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='192'>
	+ <var-decl name='zi_end' type-id='9c313c2d' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='101184'>
	- <var-decl name='zc_history_offset' type-id='9c313c2d' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='256'>
	+ <var-decl name='zi_guid' type-id='9c313c2d' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='101248'>
	- <var-decl name='zc_obj' type-id='9c313c2d' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='320'>
	+ <var-decl name='zi_level' type-id='8f92235e' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='101312'>
	- <var-decl name='zc_iflags' type-id='9c313c2d' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='352'>
	+ <var-decl name='zi_error' type-id='8f92235e' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='101376'>
	- <var-decl name='zc_share' type-id='ee5cec36' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='384'>
	+ <var-decl name='zi_type' type-id='9c313c2d' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='101632'>
	- <var-decl name='zc_objset_stats' type-id='b2c14f17' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='448'>
	+ <var-decl name='zi_freq' type-id='8f92235e' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='103936'>
	- <var-decl name='zc_begin_record' type-id='09fcdc01' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='480'>
	+ <var-decl name='zi_failfast' type-id='8f92235e' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='106368'>
	- <var-decl name='zc_inject_record' type-id='a4301ca6' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='512'>
	+ <var-decl name='zi_func' type-id='d1617432' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='109184'>
	- <var-decl name='zc_defer_destroy' type-id='8f92235e' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='2560'>
	+ <var-decl name='zi_iotype' type-id='8f92235e' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='109216'>
	- <var-decl name='zc_flags' type-id='8f92235e' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='2592'>
	+ <var-decl name='zi_duration' type-id='3ff5601b' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='109248'>
	- <var-decl name='zc_action_handle' type-id='9c313c2d' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='109312'>
	- <var-decl name='zc_cleanup_fd' type-id='95e97e5e' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='109344'>
	- <var-decl name='zc_simple' type-id='b96825af' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='109352'>
	- <var-decl name='zc_pad' type-id='d3490169' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='109376'>
	- <var-decl name='zc_sendobj' type-id='9c313c2d' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='109440'>
	- <var-decl name='zc_fromobj' type-id='9c313c2d' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='2624'>
	+ <var-decl name='zi_timer' type-id='9c313c2d' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='109504'>
	- <var-decl name='zc_createtxg' type-id='9c313c2d' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='2688'>
	+ <var-decl name='zi_nlanes' type-id='9c313c2d' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='109568'>
	- <var-decl name='zc_stat' type-id='0371a9c7' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='2752'>
	+ <var-decl name='zi_cmd' type-id='8f92235e' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='109888'>
	- <var-decl name='zc_zoneid' type-id='9c313c2d' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='2784'>
	+ <var-decl name='zi_dvas' type-id='8f92235e' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='zfs_share_t' type-id='feb6f2da' id='ee5cec36'/>
	+ <typedef-decl name='zinject_record_t' type-id='3216f820' id='a4301ca6'/>
	<class-decl name='zfs_share' size-in-bits='256' is-struct='yes' visibility='default' id='feb6f2da'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='z_exportdata' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='z_sharedata' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='z_sharetype' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	<var-decl name='z_sharemax' type-id='9c313c2d' visibility='default'/>
	</data-member>
	</class-decl>
	- <class-decl name='drr_begin' size-in-bits='2432' is-struct='yes' visibility='default' id='09fcdc01'>
	+ <typedef-decl name='zfs_share_t' type-id='feb6f2da' id='ee5cec36'/>
	+ <class-decl name='zfs_cmd' size-in-bits='109952' is-struct='yes' visibility='default' id='3522cd69'>
	<data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='drr_magic' type-id='9c313c2d' visibility='default'/>
	+ <var-decl name='zc_name' type-id='d16c6df4' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='drr_versioninfo' type-id='9c313c2d' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='32768'>
	+ <var-decl name='zc_nvlist_src' type-id='9c313c2d' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='drr_creation_time' type-id='9c313c2d' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='32832'>
	+ <var-decl name='zc_nvlist_src_size' type-id='9c313c2d' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='192'>
	- <var-decl name='drr_type' type-id='230f1e16' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='32896'>
	+ <var-decl name='zc_nvlist_dst' type-id='9c313c2d' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='224'>
	- <var-decl name='drr_flags' type-id='8f92235e' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='32960'>
	+ <var-decl name='zc_nvlist_dst_size' type-id='9c313c2d' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='256'>
	- <var-decl name='drr_toguid' type-id='9c313c2d' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='33024'>
	+ <var-decl name='zc_nvlist_dst_filled' type-id='c19b74c3' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='320'>
	- <var-decl name='drr_fromguid' type-id='9c313c2d' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='33056'>
	+ <var-decl name='zc_pad2' type-id='95e97e5e' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='384'>
	- <var-decl name='drr_toname' type-id='d1617432' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='33088'>
	+ <var-decl name='zc_history' type-id='9c313c2d' visibility='default'/>
	</data-member>
	- </class-decl>
	- <typedef-decl name='zinject_record_t' type-id='3216f820' id='a4301ca6'/>
	- <class-decl name='zinject_record' size-in-bits='2816' is-struct='yes' visibility='default' id='3216f820'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='zi_objset' type-id='9c313c2d' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='33152'>
	+ <var-decl name='zc_value' type-id='163f6aa5' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='zi_object' type-id='9c313c2d' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='98688'>
	+ <var-decl name='zc_string' type-id='d1617432' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='zi_start' type-id='9c313c2d' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='100736'>
	+ <var-decl name='zc_guid' type-id='9c313c2d' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='192'>
	- <var-decl name='zi_end' type-id='9c313c2d' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='100800'>
	+ <var-decl name='zc_nvlist_conf' type-id='9c313c2d' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='256'>
	- <var-decl name='zi_guid' type-id='9c313c2d' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='100864'>
	+ <var-decl name='zc_nvlist_conf_size' type-id='9c313c2d' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='320'>
	- <var-decl name='zi_level' type-id='8f92235e' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='100928'>
	+ <var-decl name='zc_cookie' type-id='9c313c2d' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='352'>
	- <var-decl name='zi_error' type-id='8f92235e' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='100992'>
	+ <var-decl name='zc_objset_type' type-id='9c313c2d' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='384'>
	- <var-decl name='zi_type' type-id='9c313c2d' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='101056'>
	+ <var-decl name='zc_perm_action' type-id='9c313c2d' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='448'>
	- <var-decl name='zi_freq' type-id='8f92235e' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='101120'>
	+ <var-decl name='zc_history_len' type-id='9c313c2d' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='480'>
	- <var-decl name='zi_failfast' type-id='8f92235e' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='101184'>
	+ <var-decl name='zc_history_offset' type-id='9c313c2d' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='512'>
	- <var-decl name='zi_func' type-id='d1617432' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='101248'>
	+ <var-decl name='zc_obj' type-id='9c313c2d' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='2560'>
	- <var-decl name='zi_iotype' type-id='8f92235e' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='101312'>
	+ <var-decl name='zc_iflags' type-id='9c313c2d' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='2592'>
	- <var-decl name='zi_duration' type-id='3ff5601b' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='101376'>
	+ <var-decl name='zc_share' type-id='ee5cec36' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='2624'>
	- <var-decl name='zi_timer' type-id='9c313c2d' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='101632'>
	+ <var-decl name='zc_objset_stats' type-id='b2c14f17' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='2688'>
	- <var-decl name='zi_nlanes' type-id='9c313c2d' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='103936'>
	+ <var-decl name='zc_begin_record' type-id='09fcdc01' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='2752'>
	- <var-decl name='zi_cmd' type-id='8f92235e' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='106368'>
	+ <var-decl name='zc_inject_record' type-id='a4301ca6' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='2784'>
	- <var-decl name='zi_dvas' type-id='8f92235e' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='109184'>
	+ <var-decl name='zc_defer_destroy' type-id='8f92235e' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='109216'>
	+ <var-decl name='zc_flags' type-id='8f92235e' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='109248'>
	+ <var-decl name='zc_action_handle' type-id='9c313c2d' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='109312'>
	+ <var-decl name='zc_cleanup_fd' type-id='95e97e5e' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='109344'>
	+ <var-decl name='zc_simple' type-id='b96825af' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='109352'>
	+ <var-decl name='zc_pad' type-id='d3490169' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='109376'>
	+ <var-decl name='zc_sendobj' type-id='9c313c2d' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='109440'>
	+ <var-decl name='zc_fromobj' type-id='9c313c2d' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='109504'>
	+ <var-decl name='zc_createtxg' type-id='9c313c2d' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='109568'>
	+ <var-decl name='zc_stat' type-id='0371a9c7' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='109888'>
	+ <var-decl name='zc_zoneid' type-id='9c313c2d' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='zfs_stat_t' type-id='6417f0b9' id='0371a9c7'/>
	+ <typedef-decl name='zfs_cmd_t' type-id='3522cd69' id='a5559cdd'/>
	<class-decl name='zfs_stat' size-in-bits='320' is-struct='yes' visibility='default' id='6417f0b9'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='zs_gen' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='zs_mode' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='zs_links' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	<var-decl name='zs_ctime' type-id='c1c22e6c' visibility='default'/>
	</data-member>
	</class-decl>
	+ <typedef-decl name='zfs_stat_t' type-id='6417f0b9' id='0371a9c7'/>
	+ <typedef-decl name='int16_t' type-id='03896e23' id='23bd8cb5'/>
	+ <typedef-decl name='__int16_t' type-id='a2185560' id='03896e23'/>
	<pointer-type-def type-id='c19b74c3' size-in-bits='64' id='37e3bd22'/>
	<pointer-type-def type-id='2bce87e3' size-in-bits='64' id='3aebb66f'/>
	<pointer-type-def type-id='95e97e5e' size-in-bits='64' id='7292109c'/>
	<pointer-type-def type-id='5ce45b60' size-in-bits='64' id='857bb57e'/>
	<pointer-type-def type-id='57928edf' size-in-bits='64' id='3fa542f0'/>
	<pointer-type-def type-id='eaa32e2f' size-in-bits='64' id='63e171df'/>
	<pointer-type-def type-id='3522cd69' size-in-bits='64' id='b65f7fd1'/>
	<pointer-type-def type-id='a5559cdd' size-in-bits='64' id='e4ec4540'/>
	<pointer-type-def type-id='4c81de99' size-in-bits='64' id='237193c9'/>
	- <function-decl name='namespace_clear' mangled-name='namespace_clear' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='namespace_clear'>
	- <parameter type-id='b0382bb3' name='hdl'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	- <function-decl name='zpool_get_config' mangled-name='zpool_get_config' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_get_config'>
	- <parameter type-id='4c81de99' name='zhp'/>
	- <parameter type-id='857bb57e' name='oldconfig'/>
	- <return type-id='5ce45b60'/>
	- </function-decl>
	- <function-decl name='zpool_refresh_stats' mangled-name='zpool_refresh_stats' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_refresh_stats'>
	- <parameter type-id='4c81de99' name='zhp'/>
	- <parameter type-id='37e3bd22' name='missing'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='zpool_get_features' mangled-name='zpool_get_features' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_get_features'>
	- <parameter type-id='4c81de99' name='zhp'/>
	- <return type-id='5ce45b60'/>
	+ <function-decl name='uu_avl_first' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='a5c21a38'/>
	+ <return type-id='eaa32e2f'/>
	</function-decl>
	- <function-decl name='zpool_skip_pool' mangled-name='zpool_skip_pool' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_skip_pool'>
	- <parameter type-id='80f4b756' name='poolname'/>
	- <return type-id='c19b74c3'/>
	+ <function-decl name='uu_avl_next' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='a5c21a38'/>
	+ <parameter type-id='eaa32e2f'/>
	+ <return type-id='eaa32e2f'/>
	</function-decl>
	- <function-decl name='zpool_iter' mangled-name='zpool_iter' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_iter'>
	- <parameter type-id='b0382bb3' name='hdl'/>
	- <parameter type-id='fa476e62' name='func'/>
	- <parameter type-id='eaa32e2f' name='data'/>
	- <return type-id='95e97e5e'/>
	+ <function-decl name='uu_avl_teardown' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='a5c21a38'/>
	+ <parameter type-id='63e171df'/>
	+ <return type-id='eaa32e2f'/>
	</function-decl>
	- <function-decl name='zfs_iter_root' mangled-name='zfs_iter_root' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_iter_root'>
	- <parameter type-id='b0382bb3' name='hdl'/>
	- <parameter type-id='d8e49ab9' name='func'/>
	- <parameter type-id='eaa32e2f' name='data'/>
	+ <function-decl name='zfs_ioctl' mangled-name='zfs_ioctl' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_ioctl'>
	+ <parameter type-id='b0382bb3'/>
	+ <parameter type-id='95e97e5e'/>
	+ <parameter type-id='b65f7fd1'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='libspl_assertf' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='95e97e5e'/>
	+ <function-decl name='zfs_strdup' mangled-name='zfs_strdup' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_strdup'>
	+ <parameter type-id='b0382bb3'/>
	<parameter type-id='80f4b756'/>
	- <parameter is-variadic='yes'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	- <function-decl name='nvlist_free' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='5ce45b60'/>
	- <return type-id='48b5725f'/>
	+ <return type-id='26a90f95'/>
	</function-decl>
	<function-decl name='no_memory' mangled-name='no_memory' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='no_memory'>
	<parameter type-id='b0382bb3'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='nvlist_dup' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='5ce45b60'/>
	- <parameter type-id='857bb57e'/>
	- <parameter type-id='95e97e5e'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='nvpair_name' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='3fa542f0'/>
	- <return type-id='26a90f95'/>
	- </function-decl>
	- <function-decl name='zfs_strdup' mangled-name='zfs_strdup' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_strdup'>
	+ <function-decl name='zfs_standard_error' mangled-name='zfs_standard_error' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_standard_error'>
	<parameter type-id='b0382bb3'/>
	+ <parameter type-id='95e97e5e'/>
	<parameter type-id='80f4b756'/>
	- <return type-id='26a90f95'/>
	- </function-decl>
	- <function-decl name='nvpair_value_nvlist' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='3fa542f0'/>
	- <parameter type-id='857bb57e'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='zcmd_alloc_dst_nvlist' mangled-name='zcmd_alloc_dst_nvlist' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zcmd_alloc_dst_nvlist'>
	<parameter type-id='b0382bb3'/>
	<parameter type-id='e4ec4540'/>
	<parameter type-id='b59d7dce'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zfs_ioctl' mangled-name='zfs_ioctl' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_ioctl'>
	+ <function-decl name='zcmd_expand_dst_nvlist' mangled-name='zcmd_expand_dst_nvlist' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zcmd_expand_dst_nvlist'>
	<parameter type-id='b0382bb3'/>
	- <parameter type-id='95e97e5e'/>
	- <parameter type-id='b65f7fd1'/>
	+ <parameter type-id='e4ec4540'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='__errno_location' visibility='default' binding='global' size-in-bits='64'>
	- <return type-id='7292109c'/>
	- </function-decl>
	- <function-decl name='zcmd_free_nvlists' mangled-name='zcmd_free_nvlists' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zcmd_free_nvlists'>
	+ <function-decl name='zcmd_read_dst_nvlist' mangled-name='zcmd_read_dst_nvlist' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zcmd_read_dst_nvlist'>
	+ <parameter type-id='b0382bb3'/>
	+ <parameter type-id='e4ec4540'/>
	+ <parameter type-id='857bb57e'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='zcmd_free_nvlists' mangled-name='zcmd_free_nvlists' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zcmd_free_nvlists'>
	<parameter type-id='e4ec4540'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='dcgettext' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='80f4b756'/>
	+ <function-decl name='make_dataset_handle' mangled-name='make_dataset_handle' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='make_dataset_handle'>
	+ <parameter type-id='b0382bb3'/>
	<parameter type-id='80f4b756'/>
	- <parameter type-id='95e97e5e'/>
	- <return type-id='26a90f95'/>
	+ <return type-id='9200a744'/>
	</function-decl>
	- <function-decl name='zfs_standard_error' mangled-name='zfs_standard_error' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_standard_error'>
	+ <function-decl name='zpool_open_silent' mangled-name='zpool_open_silent' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_open_silent'>
	<parameter type-id='b0382bb3'/>
	- <parameter type-id='95e97e5e'/>
	<parameter type-id='80f4b756'/>
	+ <parameter type-id='237193c9'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zcmd_expand_dst_nvlist' mangled-name='zcmd_expand_dst_nvlist' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zcmd_expand_dst_nvlist'>
	- <parameter type-id='b0382bb3'/>
	- <parameter type-id='e4ec4540'/>
	+ <function-decl name='nvlist_free' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='5ce45b60'/>
	+ <return type-id='48b5725f'/>
	+ </function-decl>
	+ <function-decl name='nvlist_dup' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='5ce45b60'/>
	+ <parameter type-id='857bb57e'/>
	+ <parameter type-id='95e97e5e'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zcmd_read_dst_nvlist' mangled-name='zcmd_read_dst_nvlist' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zcmd_read_dst_nvlist'>
	- <parameter type-id='b0382bb3'/>
	- <parameter type-id='e4ec4540'/>
	+ <function-decl name='nvlist_lookup_nvlist' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='5ce45b60'/>
	+ <parameter type-id='80f4b756'/>
	<parameter type-id='857bb57e'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='uu_avl_teardown' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='a5c21a38'/>
	- <parameter type-id='63e171df'/>
	- <return type-id='eaa32e2f'/>
	+ <function-decl name='nvlist_exists' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='5ce45b60'/>
	+ <parameter type-id='80f4b756'/>
	+ <return type-id='c19b74c3'/>
	</function-decl>
	<function-decl name='nvlist_next_nvpair' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='3fa542f0'/>
	<return type-id='3fa542f0'/>
	</function-decl>
	- <function-decl name='strcpy' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='26a90f95'/>
	- <parameter type-id='80f4b756'/>
	+ <function-decl name='nvpair_name' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='3fa542f0'/>
	<return type-id='26a90f95'/>
	</function-decl>
	- <function-decl name='nvlist_exists' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='5ce45b60'/>
	+ <function-decl name='nvpair_value_nvlist' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='3fa542f0'/>
	+ <parameter type-id='857bb57e'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='libspl_assertf' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='95e97e5e'/>
	<parameter type-id='80f4b756'/>
	+ <parameter is-variadic='yes'/>
	+ <return type-id='48b5725f'/>
	+ </function-decl>
	+ <function-decl name='namespace_clear' mangled-name='namespace_clear' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='namespace_clear'>
	+ <parameter type-id='b0382bb3' name='hdl'/>
	+ <return type-id='48b5725f'/>
	+ </function-decl>
	+ <function-decl name='zpool_get_config' mangled-name='zpool_get_config' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_get_config'>
	+ <parameter type-id='4c81de99' name='zhp'/>
	+ <parameter type-id='857bb57e' name='oldconfig'/>
	+ <return type-id='5ce45b60'/>
	+ </function-decl>
	+ <function-decl name='zpool_get_features' mangled-name='zpool_get_features' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_get_features'>
	+ <parameter type-id='4c81de99' name='zhp'/>
	+ <return type-id='5ce45b60'/>
	+ </function-decl>
	+ <function-decl name='zpool_refresh_stats' mangled-name='zpool_refresh_stats' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_refresh_stats'>
	+ <parameter type-id='4c81de99' name='zhp'/>
	+ <parameter type-id='37e3bd22' name='missing'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='zpool_skip_pool' mangled-name='zpool_skip_pool' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_skip_pool'>
	+ <parameter type-id='80f4b756' name='poolname'/>
	<return type-id='c19b74c3'/>
	</function-decl>
	- <function-decl name='nvlist_lookup_nvlist' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='5ce45b60'/>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='857bb57e'/>
	+ <function-decl name='zpool_iter' mangled-name='zpool_iter' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_iter'>
	+ <parameter type-id='b0382bb3' name='hdl'/>
	+ <parameter type-id='fa476e62' name='func'/>
	+ <parameter type-id='eaa32e2f' name='data'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='getenv' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='zfs_iter_root' mangled-name='zfs_iter_root' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_iter_root'>
	+ <parameter type-id='b0382bb3' name='hdl'/>
	+ <parameter type-id='d8e49ab9' name='func'/>
	+ <parameter type-id='eaa32e2f' name='data'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='__errno_location' visibility='default' binding='global' size-in-bits='64'>
	+ <return type-id='7292109c'/>
	+ </function-decl>
	+ <function-decl name='dcgettext' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='80f4b756'/>
	<parameter type-id='80f4b756'/>
	+ <parameter type-id='95e97e5e'/>
	<return type-id='26a90f95'/>
	</function-decl>
	- <function-decl name='uu_avl_first' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='a5c21a38'/>
	- <return type-id='eaa32e2f'/>
	- </function-decl>
	- <function-decl name='uu_avl_next' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='a5c21a38'/>
	- <parameter type-id='eaa32e2f'/>
	- <return type-id='eaa32e2f'/>
	+ <function-decl name='getenv' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='80f4b756'/>
	+ <return type-id='26a90f95'/>
	</function-decl>
	- <function-decl name='zpool_open_silent' mangled-name='zpool_open_silent' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_open_silent'>
	- <parameter type-id='b0382bb3'/>
	+ <function-decl name='strcpy' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='26a90f95'/>
	<parameter type-id='80f4b756'/>
	- <parameter type-id='237193c9'/>
	- <return type-id='95e97e5e'/>
	+ <return type-id='26a90f95'/>
	</function-decl>
	- <function-decl name='make_dataset_handle' mangled-name='make_dataset_handle' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='make_dataset_handle'>
	- <parameter type-id='b0382bb3'/>
	+ <function-decl name='strchr' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='80f4b756'/>
	- <return type-id='9200a744'/>
	+ <parameter type-id='95e97e5e'/>
	+ <return type-id='26a90f95'/>
	</function-decl>
	<function-type size-in-bits='64' id='2bce87e3'>
	<parameter type-id='4c81de99'/>
	<parameter type-id='eaa32e2f'/>
	<return type-id='95e97e5e'/>
	</function-type>
	</abi-instr>
	- <abi-instr version='1.0' address-size='64' path='libzfs_crypto.c' language='LANG_C89'>
	+ <abi-instr address-size='64' path='libzfs_crypto.c' language='LANG_C99'>
	<array-type-def dimensions='1' type-id='fb7c6451' size-in-bits='256' id='64177143'>
	- <subrange length='32' type-id='4c87fef4' id='ae5bde82'/>
	+ <subrange length='32' type-id='7359adad' id='ae5bde82'/>
	</array-type-def>
	<array-type-def dimensions='1' type-id='95e97e5e' size-in-bits='896' id='47394ee0'>
	- <subrange length='28' type-id='4c87fef4' id='3db583d7'/>
	+ <subrange length='28' type-id='7359adad' id='3db583d7'/>
	</array-type-def>
	<array-type-def dimensions='1' type-id='7359adad' size-in-bits='1024' id='d2baa450'>
	- <subrange length='16' type-id='4c87fef4' id='848d0938'/>
	+ <subrange length='16' type-id='7359adad' id='848d0938'/>
	</array-type-def>
	+ <enum-decl name='zpool_prop_t' naming-typedef-id='5d0c23fb' id='af1ba157'>
	+ <underlying-type type-id='9cac1fee'/>
	+ <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='af1ba157' id='5d0c23fb'/>
	<typedef-decl name='uint_t' type-id='f0981eeb' id='3502e3ff'/>
	- <typedef-decl name='__ssize_t' type-id='bd54fe1a' id='41060289'/>
	- <typedef-decl name='sigset_t' type-id='b9c97942' id='daf33c64'/>
	- <typedef-decl name='__sigset_t' type-id='b7c5dddc' id='b9c97942'/>
	- <class-decl name='__anonymous_struct__' size-in-bits='1024' is-struct='yes' is-anonymous='yes' naming-typedef-id='b9c97942' visibility='default' id='b7c5dddc'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='__val' type-id='d2baa450' visibility='default'/>
	- </data-member>
	- </class-decl>
	<class-decl name='sigaction' size-in-bits='1216' is-struct='yes' visibility='default' id='fe391c48'>
	<data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='__sigaction_handler' type-id='4c95ba01' visibility='default'/>
	+ <var-decl name='__sigaction_handler' type-id='ac5ab598' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='sa_mask' type-id='b9c97942' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='1088'>
	<var-decl name='sa_flags' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='1152'>
	<var-decl name='sa_restorer' type-id='953b12f8' visibility='default'/>
	</data-member>
	</class-decl>
	- <union-decl name='__anonymous_union__' size-in-bits='64' is-anonymous='yes' visibility='default' id='4c95ba01'>
	- <data-member access='private'>
	+ <union-decl name='__anonymous_union__' size-in-bits='64' is-anonymous='yes' visibility='default' id='ac5ab598'>
	+ <data-member access='public'>
	<var-decl name='sa_handler' type-id='8cdd9566' visibility='default'/>
	</data-member>
	- <data-member access='private'>
	+ <data-member access='public'>
	<var-decl name='sa_sigaction' type-id='6e756877' visibility='default'/>
	</data-member>
	</union-decl>
	- <typedef-decl name='__sighandler_t' type-id='03347643' id='8cdd9566'/>
	- <typedef-decl name='siginfo_t' type-id='57bd0028' id='cb681f62'/>
	- <class-decl name='__anonymous_struct__1' size-in-bits='1024' is-struct='yes' is-anonymous='yes' naming-typedef-id='cb681f62' visibility='default' id='57bd0028'>
	+ <class-decl name='termios' size-in-bits='480' is-struct='yes' visibility='default' id='ad55d2bc'>
	+ <data-member access='public' layout-offset-in-bits='0'>
	+ <var-decl name='c_iflag' type-id='241ce6f8' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='32'>
	+ <var-decl name='c_oflag' type-id='241ce6f8' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='64'>
	+ <var-decl name='c_cflag' type-id='241ce6f8' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='96'>
	+ <var-decl name='c_lflag' type-id='241ce6f8' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='128'>
	+ <var-decl name='c_line' type-id='fb7c6451' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='136'>
	+ <var-decl name='c_cc' type-id='64177143' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='416'>
	+ <var-decl name='c_ispeed' type-id='6a8e8a14' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='448'>
	+ <var-decl name='c_ospeed' type-id='6a8e8a14' visibility='default'/>
	+ </data-member>
	+ </class-decl>
	+ <typedef-decl name='cc_t' type-id='002ac4a6' id='fb7c6451'/>
	+ <typedef-decl name='speed_t' type-id='f0981eeb' id='6a8e8a14'/>
	+ <typedef-decl name='tcflag_t' type-id='f0981eeb' id='241ce6f8'/>
	+ <typedef-decl name='__uid_t' type-id='f0981eeb' id='cc5fcceb'/>
	+ <typedef-decl name='__pid_t' type-id='95e97e5e' id='3629bad8'/>
	+ <typedef-decl name='__clock_t' type-id='bd54fe1a' id='4d66c6d7'/>
	+ <typedef-decl name='__ssize_t' type-id='bd54fe1a' id='41060289'/>
	+ <class-decl name='__sigset_t' size-in-bits='1024' is-struct='yes' naming-typedef-id='b9c97942' visibility='default' id='2616147f'>
	+ <data-member access='public' layout-offset-in-bits='0'>
	+ <var-decl name='__val' type-id='d2baa450' visibility='default'/>
	+ </data-member>
	+ </class-decl>
	+ <typedef-decl name='__sigset_t' type-id='2616147f' id='b9c97942'/>
	+ <union-decl name='sigval' size-in-bits='64' visibility='default' id='a094b870'>
	+ <data-member access='public'>
	+ <var-decl name='sival_int' type-id='95e97e5e' visibility='default'/>
	+ </data-member>
	+ <data-member access='public'>
	+ <var-decl name='sival_ptr' type-id='eaa32e2f' visibility='default'/>
	+ </data-member>
	+ </union-decl>
	+ <typedef-decl name='__sigval_t' type-id='a094b870' id='eabacd01'/>
	+ <class-decl name='siginfo_t' size-in-bits='1024' is-struct='yes' naming-typedef-id='cb681f62' visibility='default' id='d8149419'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='si_signo' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='32'>
	<var-decl name='si_errno' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='si_code' type-id='95e97e5e' visibility='default'/>
	</data-member>
	+ <data-member access='public' layout-offset-in-bits='96'>
	+ <var-decl name='__pad0' type-id='95e97e5e' visibility='default'/>
	+ </data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='_sifields' type-id='59304ba7' visibility='default'/>
	+ <var-decl name='_sifields' type-id='ac5ab599' visibility='default'/>
	</data-member>
	</class-decl>
	- <union-decl name='__anonymous_union__1' size-in-bits='896' is-anonymous='yes' visibility='default' id='59304ba7'>
	- <data-member access='private'>
	+ <union-decl name='__anonymous_union__1' size-in-bits='896' is-anonymous='yes' visibility='default' id='ac5ab599'>
	+ <data-member access='public'>
	<var-decl name='_pad' type-id='47394ee0' visibility='default'/>
	</data-member>
	- <data-member access='private'>
	- <var-decl name='_kill' type-id='287098b3' visibility='default'/>
	+ <data-member access='public'>
	+ <var-decl name='_kill' type-id='e7f43f72' visibility='default'/>
	</data-member>
	- <data-member access='private'>
	- <var-decl name='_timer' type-id='47c4512e' visibility='default'/>
	+ <data-member access='public'>
	+ <var-decl name='_timer' type-id='e7f43f73' visibility='default'/>
	</data-member>
	- <data-member access='private'>
	- <var-decl name='_rt' type-id='4edbc456' visibility='default'/>
	+ <data-member access='public'>
	+ <var-decl name='_rt' type-id='e7f43f74' visibility='default'/>
	</data-member>
	- <data-member access='private'>
	- <var-decl name='_sigchld' type-id='28c7cf88' visibility='default'/>
	+ <data-member access='public'>
	+ <var-decl name='_sigchld' type-id='e7f43f75' visibility='default'/>
	</data-member>
	- <data-member access='private'>
	- <var-decl name='_sigfault' type-id='c7624e14' visibility='default'/>
	+ <data-member access='public'>
	+ <var-decl name='_sigfault' type-id='e7f43f76' visibility='default'/>
	</data-member>
	- <data-member access='private'>
	- <var-decl name='_sigpoll' type-id='d0d1cfc2' visibility='default'/>
	+ <data-member access='public'>
	+ <var-decl name='_sigpoll' type-id='e7f43f77' visibility='default'/>
	</data-member>
	- <data-member access='private'>
	- <var-decl name='_sigsys' type-id='07fe0781' visibility='default'/>
	+ <data-member access='public'>
	+ <var-decl name='_sigsys' type-id='e7f43f78' visibility='default'/>
	</data-member>
	</union-decl>
	- <class-decl name='__anonymous_struct__2' size-in-bits='64' is-struct='yes' is-anonymous='yes' visibility='default' id='287098b3'>
	+ <class-decl name='__anonymous_struct__1' size-in-bits='64' is-struct='yes' is-anonymous='yes' visibility='default' id='e7f43f72'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='si_pid' type-id='3629bad8' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='32'>
	<var-decl name='si_uid' type-id='cc5fcceb' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='__pid_t' type-id='95e97e5e' id='3629bad8'/>
	- <typedef-decl name='__uid_t' type-id='f0981eeb' id='cc5fcceb'/>
	- <class-decl name='__anonymous_struct__3' size-in-bits='128' is-struct='yes' is-anonymous='yes' visibility='default' id='47c4512e'>
	+ <class-decl name='__anonymous_struct__2' size-in-bits='128' is-struct='yes' is-anonymous='yes' visibility='default' id='e7f43f73'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='si_tid' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='32'>
	<var-decl name='si_overrun' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='si_sigval' type-id='95506cfb' visibility='default'/>
	+ <var-decl name='si_sigval' type-id='eabacd01' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='sigval_t' type-id='a094b870' id='95506cfb'/>
	- <union-decl name='sigval' size-in-bits='64' visibility='default' id='a094b870'>
	- <data-member access='private'>
	- <var-decl name='sival_int' type-id='95e97e5e' visibility='default'/>
	- </data-member>
	- <data-member access='private'>
	- <var-decl name='sival_ptr' type-id='eaa32e2f' visibility='default'/>
	- </data-member>
	- </union-decl>
	- <class-decl name='__anonymous_struct__4' size-in-bits='128' is-struct='yes' is-anonymous='yes' visibility='default' id='4edbc456'>
	+ <class-decl name='__anonymous_struct__3' size-in-bits='128' is-struct='yes' is-anonymous='yes' visibility='default' id='e7f43f74'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='si_pid' type-id='3629bad8' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='32'>
	<var-decl name='si_uid' type-id='cc5fcceb' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='si_sigval' type-id='95506cfb' visibility='default'/>
	+ <var-decl name='si_sigval' type-id='eabacd01' visibility='default'/>
	</data-member>
	</class-decl>
	- <class-decl name='__anonymous_struct__5' size-in-bits='256' is-struct='yes' is-anonymous='yes' visibility='default' id='28c7cf88'>
	+ <class-decl name='__anonymous_struct__4' size-in-bits='256' is-struct='yes' is-anonymous='yes' visibility='default' id='e7f43f75'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='si_pid' type-id='3629bad8' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='32'>
	<var-decl name='si_uid' type-id='cc5fcceb' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='si_status' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='si_utime' type-id='79cf34ee' visibility='default'/>
	+ <var-decl name='si_utime' type-id='4d66c6d7' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	- <var-decl name='si_stime' type-id='79cf34ee' visibility='default'/>
	+ <var-decl name='si_stime' type-id='4d66c6d7' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='__sigchld_clock_t' type-id='4d66c6d7' id='79cf34ee'/>
	- <typedef-decl name='__clock_t' type-id='bd54fe1a' id='4d66c6d7'/>
	- <class-decl name='__anonymous_struct__6' size-in-bits='64' is-struct='yes' is-anonymous='yes' visibility='default' id='c7624e14'>
	+ <class-decl name='__anonymous_struct__5' size-in-bits='256' is-struct='yes' is-anonymous='yes' visibility='default' id='e7f43f76'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='si_addr' type-id='eaa32e2f' visibility='default'/>
	</data-member>
	+ <data-member access='public' layout-offset-in-bits='64'>
	+ <var-decl name='si_addr_lsb' type-id='a2185560' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='128'>
	+ <var-decl name='_bounds' type-id='ac5ab59a' visibility='default'/>
	+ </data-member>
	+ </class-decl>
	+ <union-decl name='__anonymous_union__2' size-in-bits='128' is-anonymous='yes' visibility='default' id='ac5ab59a'>
	+ <data-member access='public'>
	+ <var-decl name='_addr_bnd' type-id='e7f43f79' visibility='default'/>
	+ </data-member>
	+ <data-member access='public'>
	+ <var-decl name='_pkey' type-id='62f1140c' visibility='default'/>
	+ </data-member>
	+ </union-decl>
	+ <class-decl name='__anonymous_struct__6' size-in-bits='128' is-struct='yes' is-anonymous='yes' visibility='default' id='e7f43f79'>
	+ <data-member access='public' layout-offset-in-bits='0'>
	+ <var-decl name='_lower' type-id='eaa32e2f' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='64'>
	+ <var-decl name='_upper' type-id='eaa32e2f' visibility='default'/>
	+ </data-member>
	</class-decl>
	- <class-decl name='__anonymous_struct__7' size-in-bits='128' is-struct='yes' is-anonymous='yes' visibility='default' id='d0d1cfc2'>
	+ <class-decl name='__anonymous_struct__7' size-in-bits='128' is-struct='yes' is-anonymous='yes' visibility='default' id='e7f43f77'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='si_band' type-id='bd54fe1a' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='si_fd' type-id='95e97e5e' visibility='default'/>
	</data-member>
	</class-decl>
	- <class-decl name='__anonymous_struct__8' size-in-bits='128' is-struct='yes' is-anonymous='yes' visibility='default' id='07fe0781'>
	+ <class-decl name='__anonymous_struct__8' size-in-bits='128' is-struct='yes' is-anonymous='yes' visibility='default' id='e7f43f78'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='_call_addr' type-id='eaa32e2f' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='_syscall' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='96'>
	<var-decl name='_arch' type-id='f0981eeb' visibility='default'/>
	</data-member>
	</class-decl>
	- <class-decl name='termios' size-in-bits='480' is-struct='yes' visibility='default' id='ad55d2bc'>
	+ <typedef-decl name='siginfo_t' type-id='d8149419' id='cb681f62'/>
	+ <typedef-decl name='sigset_t' type-id='b9c97942' id='daf33c64'/>
	+ <typedef-decl name='regoff_t' type-id='95e97e5e' id='54a2a2a8'/>
	+ <class-decl name='regmatch_t' size-in-bits='64' is-struct='yes' naming-typedef-id='1b941664' visibility='default' id='4f932615'>
	<data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='c_iflag' type-id='241ce6f8' visibility='default'/>
	+ <var-decl name='rm_so' type-id='54a2a2a8' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='32'>
	- <var-decl name='c_oflag' type-id='241ce6f8' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='c_cflag' type-id='241ce6f8' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='96'>
	- <var-decl name='c_lflag' type-id='241ce6f8' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='c_line' type-id='fb7c6451' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='136'>
	- <var-decl name='c_cc' type-id='64177143' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='416'>
	- <var-decl name='c_ispeed' type-id='6a8e8a14' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='448'>
	- <var-decl name='c_ospeed' type-id='6a8e8a14' visibility='default'/>
	- </data-member>
	- </class-decl>
	- <typedef-decl name='tcflag_t' type-id='f0981eeb' id='241ce6f8'/>
	- <typedef-decl name='cc_t' type-id='002ac4a6' id='fb7c6451'/>
	- <typedef-decl name='speed_t' type-id='f0981eeb' id='6a8e8a14'/>
	- <typedef-decl name='zpool_prop_t' type-id='08f5ca1b' id='5d0c23fb'/>
	- <enum-decl name='__anonymous_enum__' is-anonymous='yes' id='08f5ca1b'>
	- <underlying-type type-id='9cac1fee'/>
	- <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='regmatch_t' type-id='94e04c73' id='1b941664'/>
	- <class-decl name='__anonymous_struct__9' size-in-bits='64' is-struct='yes' is-anonymous='yes' naming-typedef-id='1b941664' visibility='default' id='94e04c73'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='rm_so' type-id='54a2a2a8' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='32'>
	- <var-decl name='rm_eo' type-id='54a2a2a8' visibility='default'/>
	+ <var-decl name='rm_eo' type-id='54a2a2a8' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='regoff_t' type-id='95e97e5e' id='54a2a2a8'/>
	+ <typedef-decl name='regmatch_t' type-id='4f932615' id='1b941664'/>
	+ <typedef-decl name='__sighandler_t' type-id='03347643' id='8cdd9566'/>
	<typedef-decl name='ssize_t' type-id='41060289' id='79a0948f'/>
	+ <qualified-type-def type-id='822cd80b' restrict='yes' id='e75a27e9'/>
	+ <qualified-type-def type-id='9b23c9ad' restrict='yes' id='8c85230f'/>
	+ <qualified-type-def type-id='80f4b756' restrict='yes' id='9d26089a'/>
	<qualified-type-def type-id='aca3bac8' const='yes' id='2498fd78'/>
	<pointer-type-def type-id='2498fd78' size-in-bits='64' id='eed6c816'/>
	+ <qualified-type-def type-id='eed6c816' restrict='yes' id='a431a9da'/>
	<qualified-type-def type-id='fe391c48' const='yes' id='14a93b33'/>
	<pointer-type-def type-id='14a93b33' size-in-bits='64' id='9f68085b'/>
	+ <qualified-type-def type-id='9f68085b' restrict='yes' id='e2a5e6f9'/>
	<qualified-type-def type-id='ad55d2bc' const='yes' id='a46bf13f'/>
	<pointer-type-def type-id='a46bf13f' size-in-bits='64' id='eaec840f'/>
	<qualified-type-def type-id='002ac4a6' const='yes' id='ea86de29'/>
	<pointer-type-def type-id='ea86de29' size-in-bits='64' id='354f7eb9'/>
	<qualified-type-def type-id='8efea9e5' const='yes' id='3beb2af4'/>
	<pointer-type-def type-id='3beb2af4' size-in-bits='64' id='31347b7a'/>
	<pointer-type-def type-id='31347b7a' size-in-bits='64' id='c59e1ef0'/>
	<pointer-type-def type-id='1b941664' size-in-bits='64' id='7e2979d5'/>
	+ <qualified-type-def type-id='7e2979d5' restrict='yes' id='fc212857'/>
	<pointer-type-def type-id='fe391c48' size-in-bits='64' id='568dd84e'/>
	+ <qualified-type-def type-id='568dd84e' restrict='yes' id='3d8ee6f2'/>
	<pointer-type-def type-id='cb681f62' size-in-bits='64' id='185869c1'/>
	<pointer-type-def type-id='daf33c64' size-in-bits='64' id='9e80f729'/>
	<pointer-type-def type-id='b59d7dce' size-in-bits='64' id='78c01427'/>
	+ <qualified-type-def type-id='78c01427' restrict='yes' id='d19b2c25'/>
	<pointer-type-def type-id='ad55d2bc' size-in-bits='64' id='665a4eda'/>
	<pointer-type-def type-id='9c313c2d' size-in-bits='64' id='5d6479ae'/>
	<pointer-type-def type-id='ae3e8ca6' size-in-bits='64' id='d8774064'/>
	<pointer-type-def type-id='3502e3ff' size-in-bits='64' id='4dd26a40'/>
	<pointer-type-def type-id='ee076206' size-in-bits='64' id='953b12f8'/>
	<pointer-type-def type-id='f712e2b7' size-in-bits='64' id='03347643'/>
	<pointer-type-def type-id='ef70d893' size-in-bits='64' id='6e756877'/>
	+ <qualified-type-def type-id='eaa32e2f' restrict='yes' id='1b7446cd'/>
	+ <function-decl name='zpool_get_prop_int' mangled-name='zpool_get_prop_int' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_get_prop_int'>
	+ <parameter type-id='4c81de99'/>
	+ <parameter type-id='5d0c23fb'/>
	+ <parameter type-id='debc6aa3'/>
	+ <return type-id='9c313c2d'/>
	+ </function-decl>
	+ <function-decl name='zfs_handle_dup' mangled-name='zfs_handle_dup' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_handle_dup'>
	+ <parameter type-id='9200a744'/>
	+ <return type-id='9200a744'/>
	+ </function-decl>
	+ <function-decl name='zfs_valid_proplist' mangled-name='zfs_valid_proplist' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_valid_proplist'>
	+ <parameter type-id='b0382bb3'/>
	+ <parameter type-id='2e45de5d'/>
	+ <parameter type-id='5ce45b60'/>
	+ <parameter type-id='9c313c2d'/>
	+ <parameter type-id='9200a744'/>
	+ <parameter type-id='4c81de99'/>
	+ <parameter type-id='c19b74c3'/>
	+ <parameter type-id='80f4b756'/>
	+ <return type-id='5ce45b60'/>
	+ </function-decl>
	+ <function-decl name='zfs_prop_to_name' mangled-name='zfs_prop_to_name' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_to_name'>
	+ <parameter type-id='58603c44'/>
	+ <return type-id='80f4b756'/>
	+ </function-decl>
	+ <function-decl name='zfs_iter_filesystems' mangled-name='zfs_iter_filesystems' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_iter_filesystems'>
	+ <parameter type-id='9200a744'/>
	+ <parameter type-id='d8e49ab9'/>
	+ <parameter type-id='eaa32e2f'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='zfs_parent_name' mangled-name='zfs_parent_name' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_parent_name'>
	+ <parameter type-id='9200a744'/>
	+ <parameter type-id='26a90f95'/>
	+ <parameter type-id='b59d7dce'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='lzc_load_key' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='c19b74c3'/>
	+ <parameter type-id='ae3e8ca6'/>
	+ <parameter type-id='3502e3ff'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='lzc_unload_key' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='80f4b756'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='lzc_change_key' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='9c313c2d'/>
	+ <parameter type-id='5ce45b60'/>
	+ <parameter type-id='ae3e8ca6'/>
	+ <parameter type-id='3502e3ff'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='zfs_error_aux' mangled-name='zfs_error_aux' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_error_aux'>
	+ <parameter type-id='b0382bb3'/>
	+ <parameter type-id='80f4b756'/>
	+ <parameter is-variadic='yes'/>
	+ <return type-id='48b5725f'/>
	+ </function-decl>
	+ <function-decl name='zfs_name_to_prop' mangled-name='zfs_name_to_prop' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_name_to_prop'>
	+ <parameter type-id='80f4b756'/>
	+ <return type-id='58603c44'/>
	+ </function-decl>
	+ <function-decl name='nvlist_add_uint64' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='5ce45b60'/>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='9c313c2d'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='nvlist_add_string' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='5ce45b60'/>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='80f4b756'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='nvlist_lookup_uint64' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='5ce45b60'/>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='5d6479ae'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='nvlist_lookup_string' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='5ce45b60'/>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='9b23c9ad'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='fnvlist_alloc' visibility='default' binding='global' size-in-bits='64'>
	+ <return type-id='5ce45b60'/>
	+ </function-decl>
	<function-decl name='zfs_crypto_get_encryption_root' mangled-name='zfs_crypto_get_encryption_root' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_crypto_get_encryption_root'>
	<parameter type-id='9200a744' name='zhp'/>
	<parameter type-id='37e3bd22' name='is_encroot'/>
	<parameter type-id='26a90f95' name='buf'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='zfs_crypto_create' mangled-name='zfs_crypto_create' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_crypto_create'>
	<parameter type-id='b0382bb3' name='hdl'/>
	<parameter type-id='26a90f95' name='parent_name'/>
	<parameter type-id='5ce45b60' name='props'/>
	<parameter type-id='5ce45b60' name='pool_props'/>
	<parameter type-id='c19b74c3' name='stdin_available'/>
	<parameter type-id='d8774064' name='wkeydata_out'/>
	<parameter type-id='4dd26a40' name='wkeylen_out'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='zfs_crypto_clone_check' mangled-name='zfs_crypto_clone_check' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_crypto_clone_check'>
	<parameter type-id='b0382bb3' name='hdl'/>
	<parameter type-id='9200a744' name='origin_zhp'/>
	<parameter type-id='26a90f95' name='parent_name'/>
	<parameter type-id='5ce45b60' name='props'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	+ <function-decl name='zfs_crypto_attempt_load_keys' mangled-name='zfs_crypto_attempt_load_keys' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_crypto_attempt_load_keys'>
	+ <parameter type-id='b0382bb3' name='hdl'/>
	+ <parameter type-id='26a90f95' name='fsname'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	<function-decl name='zfs_crypto_load_key' mangled-name='zfs_crypto_load_key' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_crypto_load_key'>
	<parameter type-id='9200a744' name='zhp'/>
	<parameter type-id='c19b74c3' name='noop'/>
	<parameter type-id='26a90f95' name='alt_keylocation'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zfs_crypto_attempt_load_keys' mangled-name='zfs_crypto_attempt_load_keys' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_crypto_attempt_load_keys'>
	- <parameter type-id='b0382bb3' name='hdl'/>
	- <parameter type-id='26a90f95' name='fsname'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	<function-decl name='zfs_crypto_unload_key' mangled-name='zfs_crypto_unload_key' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_crypto_unload_key'>
	<parameter type-id='9200a744' name='zhp'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='zfs_crypto_rewrap' mangled-name='zfs_crypto_rewrap' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_crypto_rewrap'>
	<parameter type-id='9200a744' name='zhp'/>
	<parameter type-id='5ce45b60' name='raw_props'/>
	<parameter type-id='c19b74c3' name='inheritkey'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zfs_prop_to_name' mangled-name='zfs_prop_to_name' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_to_name'>
	- <parameter type-id='58603c44'/>
	- <return type-id='80f4b756'/>
	+ <function-decl name='__ctype_b_loc' visibility='default' binding='global' size-in-bits='64'>
	+ <return type-id='c59e1ef0'/>
	</function-decl>
	- <function-decl name='nvlist_lookup_uint64' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='5ce45b60'/>
	+ <function-decl name='PKCS5_PBKDF2_HMAC_SHA1' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='80f4b756'/>
	- <parameter type-id='5d6479ae'/>
	+ <parameter type-id='95e97e5e'/>
	+ <parameter type-id='354f7eb9'/>
	+ <parameter type-id='95e97e5e'/>
	+ <parameter type-id='95e97e5e'/>
	+ <parameter type-id='95e97e5e'/>
	+ <parameter type-id='cf536864'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='nvlist_lookup_string' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='5ce45b60'/>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='9b23c9ad'/>
	+ <function-decl name='regexec' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='a431a9da'/>
	+ <parameter type-id='9d26089a'/>
	+ <parameter type-id='b59d7dce'/>
	+ <parameter type-id='fc212857'/>
	+ <parameter type-id='95e97e5e'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='__getdelim' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='9b23c9ad'/>
	- <parameter type-id='78c01427'/>
	+ <function-decl name='kill' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='3629bad8'/>
	<parameter type-id='95e97e5e'/>
	- <parameter type-id='822cd80b'/>
	- <return type-id='41060289'/>
	+ <return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='sigemptyset' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='9e80f729'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='sigaction' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='95e97e5e'/>
	- <parameter type-id='9f68085b'/>
	- <parameter type-id='568dd84e'/>
	+ <parameter type-id='e2a5e6f9'/>
	+ <parameter type-id='3d8ee6f2'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='fclose' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='822cd80b'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='fflush' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='822cd80b'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='printf' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='80f4b756'/>
	<parameter is-variadic='yes'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	+ <function-decl name='snprintf' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='26a90f95'/>
	+ <parameter type-id='b59d7dce'/>
	+ <parameter type-id='80f4b756'/>
	+ <parameter is-variadic='yes'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	<function-decl name='fputc' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='95e97e5e'/>
	<parameter type-id='822cd80b'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='fflush' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='__getdelim' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='8c85230f'/>
	+ <parameter type-id='d19b2c25'/>
	+ <parameter type-id='95e97e5e'/>
	+ <parameter type-id='e75a27e9'/>
	+ <return type-id='41060289'/>
	+ </function-decl>
	+ <function-decl name='fread' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='1b7446cd'/>
	+ <parameter type-id='b59d7dce'/>
	+ <parameter type-id='b59d7dce'/>
	+ <parameter type-id='e75a27e9'/>
	+ <return type-id='b59d7dce'/>
	+ </function-decl>
	+ <function-decl name='ferror' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='822cd80b'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='fileno' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='822cd80b'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	+ <function-decl name='malloc' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='b59d7dce'/>
	+ <return type-id='eaa32e2f'/>
	+ </function-decl>
	+ <function-decl name='calloc' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='b59d7dce'/>
	+ <parameter type-id='b59d7dce'/>
	+ <return type-id='eaa32e2f'/>
	+ </function-decl>
	+ <function-decl name='memcpy' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='eaa32e2f'/>
	+ <parameter type-id='eaa32e2f'/>
	+ <parameter type-id='b59d7dce'/>
	+ <return type-id='eaa32e2f'/>
	+ </function-decl>
	+ <function-decl name='strerror' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='95e97e5e'/>
	+ <return type-id='26a90f95'/>
	+ </function-decl>
	<function-decl name='tcgetattr' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='95e97e5e'/>
	<parameter type-id='665a4eda'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='tcsetattr' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='95e97e5e'/>
	<parameter type-id='95e97e5e'/>
	<parameter type-id='eaec840f'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	+ <function-decl name='close' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='95e97e5e'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='read' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='95e97e5e'/>
	+ <parameter type-id='eaa32e2f'/>
	+ <parameter type-id='b59d7dce'/>
	+ <return type-id='79a0948f'/>
	+ </function-decl>
	<function-decl name='getpid' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='3629bad8'/>
	</function-decl>
	- <function-decl name='kill' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='3629bad8'/>
	+ <function-decl name='isatty' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='95e97e5e'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zfs_error_aux' mangled-name='zfs_error_aux' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_error_aux'>
	- <parameter type-id='b0382bb3'/>
	- <parameter type-id='80f4b756'/>
	- <parameter is-variadic='yes'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	- <function-decl name='__ctype_b_loc' visibility='default' binding='global' size-in-bits='64'>
	- <return type-id='c59e1ef0'/>
	- </function-decl>
	- <function-decl name='zpool_get_prop_int' mangled-name='zpool_get_prop_int' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_get_prop_int'>
	- <parameter type-id='4c81de99'/>
	- <parameter type-id='5d0c23fb'/>
	- <parameter type-id='debc6aa3'/>
	- <return type-id='9c313c2d'/>
	- </function-decl>
	- <function-decl name='malloc' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='b59d7dce'/>
	- <return type-id='eaa32e2f'/>
	- </function-decl>
	- <function-decl name='fread' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='eaa32e2f'/>
	- <parameter type-id='b59d7dce'/>
	- <parameter type-id='b59d7dce'/>
	- <parameter type-id='822cd80b'/>
	- <return type-id='b59d7dce'/>
	- </function-decl>
	- <function-decl name='ferror' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='822cd80b'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='strerror' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='95e97e5e'/>
	- <return type-id='26a90f95'/>
	- </function-decl>
	- <function-decl name='fclose' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='822cd80b'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='sscanf' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='80f4b756'/>
	- <parameter is-variadic='yes'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='PKCS5_PBKDF2_HMAC_SHA1' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='95e97e5e'/>
	- <parameter type-id='354f7eb9'/>
	- <parameter type-id='95e97e5e'/>
	- <parameter type-id='95e97e5e'/>
	- <parameter type-id='95e97e5e'/>
	- <parameter type-id='cf536864'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='bcopy' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='eaa32e2f'/>
	- <parameter type-id='eaa32e2f'/>
	- <parameter type-id='b59d7dce'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	- <function-decl name='calloc' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='b59d7dce'/>
	- <parameter type-id='b59d7dce'/>
	- <return type-id='eaa32e2f'/>
	- </function-decl>
	- <function-decl name='regexec' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='eed6c816'/>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='b59d7dce'/>
	- <parameter type-id='7e2979d5'/>
	- <parameter type-id='95e97e5e'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='isatty' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='95e97e5e'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='read' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='95e97e5e'/>
	- <parameter type-id='eaa32e2f'/>
	- <parameter type-id='b59d7dce'/>
	- <return type-id='79a0948f'/>
	- </function-decl>
	- <function-decl name='close' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='95e97e5e'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='nvlist_add_uint64' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='5ce45b60'/>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='9c313c2d'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='snprintf' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='26a90f95'/>
	- <parameter type-id='b59d7dce'/>
	- <parameter type-id='80f4b756'/>
	- <parameter is-variadic='yes'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='nvlist_add_string' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='5ce45b60'/>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='80f4b756'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='lzc_load_key' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='c19b74c3'/>
	- <parameter type-id='ae3e8ca6'/>
	- <parameter type-id='3502e3ff'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='zfs_iter_filesystems' mangled-name='zfs_iter_filesystems' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_iter_filesystems'>
	- <parameter type-id='9200a744'/>
	- <parameter type-id='d8e49ab9'/>
	- <parameter type-id='eaa32e2f'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='zfs_handle_dup' mangled-name='zfs_handle_dup' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_handle_dup'>
	- <parameter type-id='9200a744'/>
	- <return type-id='9200a744'/>
	- </function-decl>
	- <function-decl name='lzc_unload_key' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='80f4b756'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='zfs_name_to_prop' mangled-name='zfs_name_to_prop' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_name_to_prop'>
	- <parameter type-id='80f4b756'/>
	- <return type-id='58603c44'/>
	- </function-decl>
	- <function-decl name='fnvlist_alloc' visibility='default' binding='global' size-in-bits='64'>
	- <return type-id='5ce45b60'/>
	- </function-decl>
	- <function-decl name='zfs_valid_proplist' mangled-name='zfs_valid_proplist' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_valid_proplist'>
	- <parameter type-id='b0382bb3'/>
	- <parameter type-id='2e45de5d'/>
	- <parameter type-id='5ce45b60'/>
	- <parameter type-id='9c313c2d'/>
	- <parameter type-id='9200a744'/>
	- <parameter type-id='4c81de99'/>
	- <parameter type-id='c19b74c3'/>
	- <parameter type-id='80f4b756'/>
	- <return type-id='5ce45b60'/>
	- </function-decl>
	- <function-decl name='zfs_parent_name' mangled-name='zfs_parent_name' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_parent_name'>
	- <parameter type-id='9200a744'/>
	- <parameter type-id='26a90f95'/>
	- <parameter type-id='b59d7dce'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='lzc_change_key' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='9c313c2d'/>
	- <parameter type-id='5ce45b60'/>
	- <parameter type-id='ae3e8ca6'/>
	- <parameter type-id='3502e3ff'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-type size-in-bits='64' id='ee076206'>
	+ <function-type size-in-bits='64' id='ee076206'>
	<return type-id='48b5725f'/>
	</function-type>
	<function-type size-in-bits='64' id='f712e2b7'>
	<parameter type-id='95e97e5e'/>
	<return type-id='48b5725f'/>
	</function-type>
	<function-type size-in-bits='64' id='ef70d893'>
	<parameter type-id='95e97e5e'/>
	<parameter type-id='185869c1'/>
	<parameter type-id='eaa32e2f'/>
	<return type-id='48b5725f'/>
	</function-type>
	</abi-instr>
	- <abi-instr version='1.0' address-size='64' path='libzfs_dataset.c' language='LANG_C89'>
	+ <abi-instr address-size='64' path='libzfs_dataset.c' language='LANG_C99'>
	<array-type-def dimensions='1' type-id='a84c031d' size-in-bits='32' id='8e0573fd'>
	- <subrange length='4' type-id='4c87fef4' id='16fe7105'/>
	+ <subrange length='4' type-id='7359adad' id='16fe7105'/>
	</array-type-def>
	- <class-decl name='mnttab' size-in-bits='256' is-struct='yes' visibility='default' id='1b055409'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='mnt_special' type-id='26a90f95' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='mnt_mountp' type-id='26a90f95' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='mnt_fstype' type-id='26a90f95' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='192'>
	- <var-decl name='mnt_mntopts' type-id='26a90f95' visibility='default'/>
	- </data-member>
	- </class-decl>
	- <typedef-decl name='renameflags_t' type-id='7aee5792' id='067170c2'/>
	- <class-decl name='renameflags' size-in-bits='32' is-struct='yes' visibility='default' id='7aee5792'>
	- <data-member access='public' layout-offset-in-bits='31'>
	- <var-decl name='recursive' type-id='95e97e5e' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='30'>
	- <var-decl name='nounmount' type-id='95e97e5e' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='29'>
	- <var-decl name='forceunmount' type-id='95e97e5e' visibility='default'/>
	- </data-member>
	- </class-decl>
	- <typedef-decl name='zprop_list_t' type-id='bd9b4291' id='bdb8ac4f'/>
	<class-decl name='zprop_list' size-in-bits='448' is-struct='yes' visibility='default' id='bd9b4291'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='pl_prop' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='pl_user_prop' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='pl_next' type-id='9f1a1109' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	<var-decl name='pl_all' type-id='c19b74c3' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='256'>
	<var-decl name='pl_width' type-id='b59d7dce' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='320'>
	<var-decl name='pl_recvd_width' type-id='b59d7dce' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='384'>
	<var-decl name='pl_fixed' type-id='c19b74c3' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='zfs_userquota_prop_t' type-id='08f5ca1c' id='279fde6a'/>
	- <enum-decl name='__anonymous_enum__' is-anonymous='yes' id='08f5ca1c'>
	+ <typedef-decl name='zprop_list_t' type-id='bd9b4291' id='bdb8ac4f'/>
	+ <class-decl name='renameflags' size-in-bits='32' is-struct='yes' visibility='default' id='7aee5792'>
	+ <data-member access='public' layout-offset-in-bits='0'>
	+ <var-decl name='recursive' type-id='95e97e5e' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='1'>
	+ <var-decl name='nounmount' type-id='95e97e5e' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='2'>
	+ <var-decl name='forceunmount' type-id='95e97e5e' visibility='default'/>
	+ </data-member>
	+ </class-decl>
	+ <typedef-decl name='renameflags_t' type-id='7aee5792' id='067170c2'/>
	+ <typedef-decl name='zfs_userspace_cb_t' type-id='ca64ff60' id='16c5f410'/>
	+ <enum-decl name='lzc_dataset_type' id='bc9887f1'>
	+ <underlying-type type-id='9cac1fee'/>
	+ <enumerator name='LZC_DATSET_TYPE_ZFS' value='2'/>
	+ <enumerator name='LZC_DATSET_TYPE_ZVOL' value='3'/>
	+ </enum-decl>
	+ <typedef-decl name='avl_index_t' type-id='e475ab95' id='fba6cb51'/>
	+ <enum-decl name='zfs_userquota_prop_t' naming-typedef-id='279fde6a' id='5258d2f6'>
	<underlying-type type-id='9cac1fee'/>
	<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_userspace_cb_t' type-id='ca64ff60' id='16c5f410'/>
	- <typedef-decl name='uid_t' type-id='cc5fcceb' id='354978ed'/>
	- <typedef-decl name='zfs_wait_activity_t' type-id='40ed39d5' id='3024501a'/>
	- <enum-decl name='__anonymous_enum__1' is-anonymous='yes' id='40ed39d5'>
	+ <typedef-decl name='zfs_userquota_prop_t' type-id='5258d2f6' id='279fde6a'/>
	+ <enum-decl name='zfs_wait_activity_t' naming-typedef-id='3024501a' id='527d5dc6'>
	<underlying-type type-id='9cac1fee'/>
	<enumerator name='ZFS_WAIT_DELETEQ' value='0'/>
	<enumerator name='ZFS_WAIT_NUM_ACTIVITIES' value='1'/>
	</enum-decl>
	- <typedef-decl name='int64_t' type-id='bd54fe1a' id='9da381c4'/>
	- <typedef-decl name='zprop_type_t' type-id='3fed383f' id='31429eff'/>
	- <enum-decl name='__anonymous_enum__2' is-anonymous='yes' id='3fed383f'>
	+ <typedef-decl name='zfs_wait_activity_t' type-id='527d5dc6' id='3024501a'/>
	+ <enum-decl name='namecheck_err_t' naming-typedef-id='8e0af06e' id='f43bbcda'>
	+ <underlying-type type-id='9cac1fee'/>
	+ <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='f43bbcda' id='8e0af06e'/>
	+ <enum-decl name='zprop_type_t' naming-typedef-id='31429eff' id='87676253'>
	<underlying-type type-id='9cac1fee'/>
	<enumerator name='PROP_TYPE_NUMBER' value='0'/>
	<enumerator name='PROP_TYPE_STRING' value='1'/>
	<enumerator name='PROP_TYPE_INDEX' value='2'/>
	</enum-decl>
	- <class-decl name='passwd' size-in-bits='384' is-struct='yes' visibility='default' id='a63d15a3'>
	+ <typedef-decl name='zprop_type_t' type-id='87676253' id='31429eff'/>
	+ <class-decl name='mnttab' size-in-bits='256' is-struct='yes' visibility='default' id='1b055409'>
	<data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='pw_name' type-id='26a90f95' visibility='default'/>
	+ <var-decl name='mnt_special' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='pw_passwd' type-id='26a90f95' visibility='default'/>
	+ <var-decl name='mnt_mountp' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='pw_uid' type-id='cc5fcceb' visibility='default'/>
	+ <var-decl name='mnt_fstype' type-id='26a90f95' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='192'>
	+ <var-decl name='mnt_mntopts' type-id='26a90f95' visibility='default'/>
	+ </data-member>
	+ </class-decl>
	+ <union-decl name='pthread_mutexattr_t' size-in-bits='32' naming-typedef-id='8afd6070' visibility='default' id='7300eb00'>
	+ <data-member access='public'>
	+ <var-decl name='__size' type-id='8e0573fd' visibility='default'/>
	+ </data-member>
	+ <data-member access='public'>
	+ <var-decl name='__align' type-id='95e97e5e' visibility='default'/>
	+ </data-member>
	+ </union-decl>
	+ <typedef-decl name='pthread_mutexattr_t' type-id='7300eb00' id='8afd6070'/>
	+ <typedef-decl name='int64_t' type-id='0c9942d2' id='9da381c4'/>
	+ <typedef-decl name='__int64_t' type-id='bd54fe1a' id='0c9942d2'/>
	+ <typedef-decl name='__gid_t' type-id='f0981eeb' id='d94ec6d9'/>
	+ <typedef-decl name='__time_t' type-id='bd54fe1a' id='65eda9c0'/>
	+ <class-decl name='tm' size-in-bits='448' is-struct='yes' visibility='default' id='dddf6ca2'>
	+ <data-member access='public' layout-offset-in-bits='0'>
	+ <var-decl name='tm_sec' type-id='95e97e5e' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='32'>
	+ <var-decl name='tm_min' type-id='95e97e5e' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='64'>
	+ <var-decl name='tm_hour' type-id='95e97e5e' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='96'>
	+ <var-decl name='tm_mday' type-id='95e97e5e' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='128'>
	+ <var-decl name='tm_mon' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='160'>
	- <var-decl name='pw_gid' type-id='d94ec6d9' visibility='default'/>
	+ <var-decl name='tm_year' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	- <var-decl name='pw_gecos' type-id='26a90f95' visibility='default'/>
	+ <var-decl name='tm_wday' type-id='95e97e5e' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='224'>
	+ <var-decl name='tm_yday' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='256'>
	- <var-decl name='pw_dir' type-id='26a90f95' visibility='default'/>
	+ <var-decl name='tm_isdst' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='320'>
	- <var-decl name='pw_shell' type-id='26a90f95' visibility='default'/>
	+ <var-decl name='tm_gmtoff' type-id='bd54fe1a' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='384'>
	+ <var-decl name='tm_zone' type-id='80f4b756' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='__gid_t' type-id='f0981eeb' id='d94ec6d9'/>
	+ <typedef-decl name='time_t' type-id='65eda9c0' id='c9d12d66'/>
	<class-decl name='group' size-in-bits='256' is-struct='yes' visibility='default' id='01a1b934'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='gr_name' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='gr_passwd' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='gr_gid' type-id='d94ec6d9' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	<var-decl name='gr_mem' type-id='9b23c9ad' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='namecheck_err_t' type-id='3eed36ac' id='8e0af06e'/>
	- <enum-decl name='__anonymous_enum__3' is-anonymous='yes' id='3eed36ac'>
	- <underlying-type type-id='9cac1fee'/>
	- <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='pthread_mutexattr_t' type-id='e7fcd879' id='8afd6070'/>
	- <union-decl name='__anonymous_union__' size-in-bits='32' is-anonymous='yes' visibility='default' id='e7fcd879'>
	- <data-member access='private'>
	- <var-decl name='__size' type-id='8e0573fd' visibility='default'/>
	- </data-member>
	- <data-member access='private'>
	- <var-decl name='__align' type-id='95e97e5e' visibility='default'/>
	- </data-member>
	- </union-decl>
	- <typedef-decl name='avl_index_t' type-id='e475ab95' id='fba6cb51'/>
	<class-decl name='mntent' size-in-bits='320' is-struct='yes' visibility='default' id='56fe4a37'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='mnt_fsname' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='mnt_dir' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='mnt_type' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	<var-decl name='mnt_opts' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='256'>
	<var-decl name='mnt_freq' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='288'>
	<var-decl name='mnt_passno' type-id='95e97e5e' visibility='default'/>
	</data-member>
	</class-decl>
	- <class-decl name='tm' size-in-bits='448' is-struct='yes' visibility='default' id='dddf6ca2'>
	+ <class-decl name='passwd' size-in-bits='384' is-struct='yes' visibility='default' id='a63d15a3'>
	<data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='tm_sec' type-id='95e97e5e' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='32'>
	- <var-decl name='tm_min' type-id='95e97e5e' visibility='default'/>
	+ <var-decl name='pw_name' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='tm_hour' type-id='95e97e5e' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='96'>
	- <var-decl name='tm_mday' type-id='95e97e5e' visibility='default'/>
	+ <var-decl name='pw_passwd' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='tm_mon' type-id='95e97e5e' visibility='default'/>
	+ <var-decl name='pw_uid' type-id='cc5fcceb' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='160'>
	- <var-decl name='tm_year' type-id='95e97e5e' visibility='default'/>
	+ <var-decl name='pw_gid' type-id='d94ec6d9' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	- <var-decl name='tm_wday' type-id='95e97e5e' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='224'>
	- <var-decl name='tm_yday' type-id='95e97e5e' visibility='default'/>
	+ <var-decl name='pw_gecos' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='256'>
	- <var-decl name='tm_isdst' type-id='95e97e5e' visibility='default'/>
	+ <var-decl name='pw_dir' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='320'>
	- <var-decl name='tm_gmtoff' type-id='bd54fe1a' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='384'>
	- <var-decl name='tm_zone' type-id='80f4b756' visibility='default'/>
	+ <var-decl name='pw_shell' type-id='26a90f95' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='time_t' type-id='65eda9c0' id='c9d12d66'/>
	- <typedef-decl name='__time_t' type-id='bd54fe1a' id='65eda9c0'/>
	- <enum-decl name='lzc_dataset_type' id='bc9887f1'>
	- <underlying-type type-id='9cac1fee'/>
	- <enumerator name='LZC_DATSET_TYPE_ZFS' value='2'/>
	- <enumerator name='LZC_DATSET_TYPE_ZVOL' value='3'/>
	- </enum-decl>
	+ <typedef-decl name='uid_t' type-id='cc5fcceb' id='354978ed'/>
	<pointer-type-def type-id='fba6cb51' size-in-bits='64' id='32adbf30'/>
	<pointer-type-def type-id='f20fbd51' size-in-bits='64' id='a3681dea'/>
	+ <qualified-type-def type-id='26a90f95' restrict='yes' id='266fe297'/>
	<pointer-type-def type-id='80f4b756' size-in-bits='64' id='7d3cd834'/>
	<qualified-type-def type-id='56fe4a37' const='yes' id='a75125ce'/>
	<pointer-type-def type-id='a75125ce' size-in-bits='64' id='48bea5ec'/>
	<qualified-type-def type-id='8afd6070' const='yes' id='1d853360'/>
	<pointer-type-def type-id='1d853360' size-in-bits='64' id='c2afbd7e'/>
	<qualified-type-def type-id='c9d12d66' const='yes' id='588b3216'/>
	<pointer-type-def type-id='588b3216' size-in-bits='64' id='9f201474'/>
	+ <qualified-type-def type-id='9f201474' restrict='yes' id='d6e2847c'/>
	<qualified-type-def type-id='dddf6ca2' const='yes' id='e824a34f'/>
	<pointer-type-def type-id='e824a34f' size-in-bits='64' id='d6ad37ff'/>
	+ <qualified-type-def type-id='d6ad37ff' restrict='yes' id='f8c6051d'/>
	<pointer-type-def type-id='01a1b934' size-in-bits='64' id='566b3f52'/>
	<pointer-type-def type-id='7e291ce6' size-in-bits='64' id='ca64ff60'/>
	<pointer-type-def type-id='9da381c4' size-in-bits='64' id='cb785ebf'/>
	<pointer-type-def type-id='1b055409' size-in-bits='64' id='9d424d31'/>
	<pointer-type-def type-id='8e0af06e' size-in-bits='64' id='053457bd'/>
	<pointer-type-def type-id='857bb57e' size-in-bits='64' id='75be733c'/>
	<pointer-type-def type-id='a63d15a3' size-in-bits='64' id='a195f4a3'/>
	<pointer-type-def type-id='7a6844eb' size-in-bits='64' id='18c91f9e'/>
	<pointer-type-def type-id='dddf6ca2' size-in-bits='64' id='d915a820'/>
	+ <qualified-type-def type-id='d915a820' restrict='yes' id='f099ad08'/>
	<pointer-type-def type-id='5d6479ae' size-in-bits='64' id='892b4acc'/>
	<pointer-type-def type-id='bd9b4291' size-in-bits='64' id='9f1a1109'/>
	<pointer-type-def type-id='bdb8ac4f' size-in-bits='64' id='3a9b2288'/>
	<pointer-type-def type-id='3a9b2288' size-in-bits='64' id='e4378506'/>
	- <function-decl name='zfs_type_to_name' mangled-name='zfs_type_to_name' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_type_to_name'>
	- <parameter type-id='2e45de5d' name='type'/>
	- <return type-id='80f4b756'/>
	- </function-decl>
	- <function-decl name='zfs_validate_name' mangled-name='zfs_validate_name' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_validate_name'>
	- <parameter type-id='b0382bb3' name='hdl'/>
	- <parameter type-id='80f4b756' name='path'/>
	- <parameter type-id='95e97e5e' name='type'/>
	- <parameter type-id='c19b74c3' name='modifying'/>
	- <return type-id='95e97e5e'/>
	+ <function-decl name='zpool_open' mangled-name='zpool_open' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_open'>
	+ <parameter type-id='b0382bb3'/>
	+ <parameter type-id='80f4b756'/>
	+ <return type-id='4c81de99'/>
	</function-decl>
	- <function-decl name='zfs_name_valid' mangled-name='zfs_name_valid' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_name_valid'>
	- <parameter type-id='80f4b756' name='name'/>
	- <parameter type-id='2e45de5d' name='type'/>
	- <return type-id='95e97e5e'/>
	+ <function-decl name='zpool_open_canfail' mangled-name='zpool_open_canfail' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_open_canfail'>
	+ <parameter type-id='b0382bb3'/>
	+ <parameter type-id='80f4b756'/>
	+ <return type-id='4c81de99'/>
	</function-decl>
	- <function-decl name='zpool_free_handles' mangled-name='zpool_free_handles' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_free_handles'>
	- <parameter type-id='b0382bb3' name='hdl'/>
	+ <function-decl name='zpool_close' mangled-name='zpool_close' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_close'>
	+ <parameter type-id='4c81de99'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='make_dataset_handle_zc' mangled-name='make_dataset_handle_zc' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='make_dataset_handle_zc'>
	- <parameter type-id='b0382bb3' name='hdl'/>
	- <parameter type-id='e4ec4540' name='zc'/>
	- <return type-id='9200a744'/>
	+ <function-decl name='zpool_get_name' mangled-name='zpool_get_name' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_get_name'>
	+ <parameter type-id='4c81de99'/>
	+ <return type-id='80f4b756'/>
	</function-decl>
	- <function-decl name='make_dataset_simple_handle_zc' mangled-name='make_dataset_simple_handle_zc' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='make_dataset_simple_handle_zc'>
	- <parameter type-id='9200a744' name='pzhp'/>
	- <parameter type-id='e4ec4540' name='zc'/>
	- <return type-id='9200a744'/>
	+ <function-decl name='zpool_get_prop' mangled-name='zpool_get_prop' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_get_prop'>
	+ <parameter type-id='4c81de99'/>
	+ <parameter type-id='5d0c23fb'/>
	+ <parameter type-id='26a90f95'/>
	+ <parameter type-id='b59d7dce'/>
	+ <parameter type-id='debc6aa3'/>
	+ <parameter type-id='c19b74c3'/>
	+ <return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zfs_bookmark_exists' mangled-name='zfs_bookmark_exists' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_bookmark_exists'>
	- <parameter type-id='80f4b756' name='path'/>
	- <return type-id='c19b74c3'/>
	+ <function-decl name='zfs_prop_default_string' mangled-name='zfs_prop_default_string' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_default_string'>
	+ <parameter type-id='58603c44'/>
	+ <return type-id='80f4b756'/>
	</function-decl>
	- <function-decl name='make_bookmark_handle' mangled-name='make_bookmark_handle' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='make_bookmark_handle'>
	- <parameter type-id='9200a744' name='parent'/>
	- <parameter type-id='80f4b756' name='path'/>
	- <parameter type-id='5ce45b60' name='bmark_props'/>
	- <return type-id='9200a744'/>
	+ <function-decl name='zfs_prop_default_numeric' mangled-name='zfs_prop_default_numeric' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_default_numeric'>
	+ <parameter type-id='58603c44'/>
	+ <return type-id='9c313c2d'/>
	</function-decl>
	- <function-decl name='libzfs_mnttab_init' mangled-name='libzfs_mnttab_init' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libzfs_mnttab_init'>
	- <parameter type-id='b0382bb3' name='hdl'/>
	- <return type-id='48b5725f'/>
	+ <function-decl name='zpool_prop_get_feature' mangled-name='zpool_prop_get_feature' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_prop_get_feature'>
	+ <parameter type-id='4c81de99'/>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='26a90f95'/>
	+ <parameter type-id='b59d7dce'/>
	+ <return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='libzfs_mnttab_fini' mangled-name='libzfs_mnttab_fini' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libzfs_mnttab_fini'>
	- <parameter type-id='b0382bb3' name='hdl'/>
	- <return type-id='48b5725f'/>
	+ <function-decl name='zfs_iter_snapshots' mangled-name='zfs_iter_snapshots' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_iter_snapshots'>
	+ <parameter type-id='9200a744'/>
	+ <parameter type-id='c19b74c3'/>
	+ <parameter type-id='d8e49ab9'/>
	+ <parameter type-id='eaa32e2f'/>
	+ <parameter type-id='9c313c2d'/>
	+ <parameter type-id='9c313c2d'/>
	+ <return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='libzfs_mnttab_cache' mangled-name='libzfs_mnttab_cache' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libzfs_mnttab_cache'>
	- <parameter type-id='b0382bb3' name='hdl'/>
	- <parameter type-id='c19b74c3' name='enable'/>
	- <return type-id='48b5725f'/>
	+ <function-decl name='zfs_iter_bookmarks' mangled-name='zfs_iter_bookmarks' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_iter_bookmarks'>
	+ <parameter type-id='9200a744'/>
	+ <parameter type-id='d8e49ab9'/>
	+ <parameter type-id='eaa32e2f'/>
	+ <return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='libzfs_mnttab_find' mangled-name='libzfs_mnttab_find' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libzfs_mnttab_find'>
	- <parameter type-id='b0382bb3' name='hdl'/>
	- <parameter type-id='80f4b756' name='fsname'/>
	- <parameter type-id='9d424d31' name='entry'/>
	+ <function-decl name='zfs_share' mangled-name='zfs_share' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_share'>
	+ <parameter type-id='9200a744'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='libzfs_mnttab_add' mangled-name='libzfs_mnttab_add' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libzfs_mnttab_add'>
	- <parameter type-id='b0382bb3' name='hdl'/>
	- <parameter type-id='80f4b756' name='special'/>
	- <parameter type-id='80f4b756' name='mountp'/>
	- <parameter type-id='80f4b756' name='mntopts'/>
	+ <function-decl name='zfs_commit_all_shares' mangled-name='zfs_commit_all_shares' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_commit_all_shares'>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='libzfs_mnttab_remove' mangled-name='libzfs_mnttab_remove' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libzfs_mnttab_remove'>
	- <parameter type-id='b0382bb3' name='hdl'/>
	- <parameter type-id='80f4b756' name='fsname'/>
	- <return type-id='48b5725f'/>
	+ <function-decl name='zfs_nicestrtonum' mangled-name='zfs_nicestrtonum' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_nicestrtonum'>
	+ <parameter type-id='b0382bb3'/>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='5d6479ae'/>
	+ <return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zfs_spa_version' mangled-name='zfs_spa_version' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_spa_version'>
	- <parameter type-id='9200a744' name='zhp'/>
	- <parameter type-id='7292109c' name='spa_version'/>
	+ <function-decl name='lzc_snapshot' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='5ce45b60'/>
	+ <parameter type-id='5ce45b60'/>
	+ <parameter type-id='857bb57e'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='getprop_uint64' mangled-name='getprop_uint64' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='getprop_uint64'>
	- <parameter type-id='9200a744' name='zhp'/>
	- <parameter type-id='58603c44' name='prop'/>
	- <parameter type-id='9b23c9ad' name='source'/>
	- <return type-id='9c313c2d'/>
	+ <function-decl name='lzc_create' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='bc9887f1'/>
	+ <parameter type-id='5ce45b60'/>
	+ <parameter type-id='ae3e8ca6'/>
	+ <parameter type-id='3502e3ff'/>
	+ <return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zfs_prop_inherit' mangled-name='zfs_prop_inherit' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_inherit'>
	- <parameter type-id='9200a744' name='zhp'/>
	- <parameter type-id='80f4b756' name='propname'/>
	- <parameter type-id='c19b74c3' name='received'/>
	+ <function-decl name='lzc_clone' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='5ce45b60'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zfs_prop_get_numeric' mangled-name='zfs_prop_get_numeric' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_get_numeric'>
	- <parameter type-id='9200a744' name='zhp'/>
	- <parameter type-id='58603c44' name='prop'/>
	- <parameter type-id='5d6479ae' name='value'/>
	- <parameter type-id='debc6aa3' name='src'/>
	- <parameter type-id='26a90f95' name='statbuf'/>
	- <parameter type-id='b59d7dce' name='statlen'/>
	+ <function-decl name='lzc_promote' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='26a90f95'/>
	+ <parameter type-id='95e97e5e'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zfs_prop_get_userquota_int' mangled-name='zfs_prop_get_userquota_int' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_get_userquota_int'>
	- <parameter type-id='9200a744' name='zhp'/>
	- <parameter type-id='80f4b756' name='propname'/>
	- <parameter type-id='5d6479ae' name='propvalue'/>
	+ <function-decl name='lzc_destroy_snaps' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='5ce45b60'/>
	+ <parameter type-id='c19b74c3'/>
	+ <parameter type-id='857bb57e'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zfs_prop_get_userquota' mangled-name='zfs_prop_get_userquota' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_get_userquota'>
	- <parameter type-id='9200a744' name='zhp'/>
	- <parameter type-id='80f4b756' name='propname'/>
	- <parameter type-id='26a90f95' name='propbuf'/>
	- <parameter type-id='95e97e5e' name='proplen'/>
	- <parameter type-id='c19b74c3' name='literal'/>
	+ <function-decl name='lzc_get_bookmarks' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='5ce45b60'/>
	+ <parameter type-id='857bb57e'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zfs_prop_get_written_int' mangled-name='zfs_prop_get_written_int' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_get_written_int'>
	- <parameter type-id='9200a744' name='zhp'/>
	- <parameter type-id='80f4b756' name='propname'/>
	- <parameter type-id='5d6479ae' name='propvalue'/>
	+ <function-decl name='lzc_destroy_bookmarks' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='5ce45b60'/>
	+ <parameter type-id='857bb57e'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zfs_prop_get_written' mangled-name='zfs_prop_get_written' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_get_written'>
	- <parameter type-id='9200a744' name='zhp'/>
	- <parameter type-id='80f4b756' name='propname'/>
	- <parameter type-id='26a90f95' name='propbuf'/>
	- <parameter type-id='95e97e5e' name='proplen'/>
	- <parameter type-id='c19b74c3' name='literal'/>
	+ <function-decl name='lzc_hold' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='5ce45b60'/>
	+ <parameter type-id='95e97e5e'/>
	+ <parameter type-id='857bb57e'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zfs_get_clones_nvl' mangled-name='zfs_get_clones_nvl' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_get_clones_nvl'>
	- <parameter type-id='9200a744' name='zhp'/>
	- <return type-id='5ce45b60'/>
	+ <function-decl name='lzc_release' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='5ce45b60'/>
	+ <parameter type-id='857bb57e'/>
	+ <return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zfs_prop_get_recvd' mangled-name='zfs_prop_get_recvd' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_get_recvd'>
	- <parameter type-id='9200a744' name='zhp'/>
	- <parameter type-id='80f4b756' name='propname'/>
	- <parameter type-id='26a90f95' name='propbuf'/>
	- <parameter type-id='b59d7dce' name='proplen'/>
	- <parameter type-id='c19b74c3' name='literal'/>
	+ <function-decl name='lzc_get_holds' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='857bb57e'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zfs_get_pool_name' mangled-name='zfs_get_pool_name' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_get_pool_name'>
	- <parameter type-id='fcd57163' name='zhp'/>
	- <return type-id='80f4b756'/>
	- </function-decl>
	- <function-decl name='zfs_get_type' mangled-name='zfs_get_type' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_get_type'>
	- <parameter type-id='fcd57163' name='zhp'/>
	- <return type-id='2e45de5d'/>
	- </function-decl>
	- <function-decl name='zfs_dataset_exists' mangled-name='zfs_dataset_exists' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_dataset_exists'>
	- <parameter type-id='b0382bb3' name='hdl'/>
	- <parameter type-id='80f4b756' name='path'/>
	- <parameter type-id='2e45de5d' name='types'/>
	+ <function-decl name='lzc_exists' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='80f4b756'/>
	<return type-id='c19b74c3'/>
	</function-decl>
	- <function-decl name='zfs_create' mangled-name='zfs_create' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_create'>
	- <parameter type-id='b0382bb3' name='hdl'/>
	- <parameter type-id='80f4b756' name='path'/>
	- <parameter type-id='2e45de5d' name='type'/>
	- <parameter type-id='5ce45b60' name='props'/>
	+ <function-decl name='lzc_rollback_to' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='80f4b756'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='create_parents' mangled-name='create_parents' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='create_parents'>
	- <parameter type-id='b0382bb3' name='hdl'/>
	- <parameter type-id='26a90f95' name='target'/>
	- <parameter type-id='95e97e5e' name='prefixlen'/>
	+ <function-decl name='lzc_destroy' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='80f4b756'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zfs_create_ancestors' mangled-name='zfs_create_ancestors' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_create_ancestors'>
	- <parameter type-id='b0382bb3' name='hdl'/>
	- <parameter type-id='80f4b756' name='path'/>
	+ <function-decl name='lzc_channel_program_nosync' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='9c313c2d'/>
	+ <parameter type-id='9c313c2d'/>
	+ <parameter type-id='5ce45b60'/>
	+ <parameter type-id='857bb57e'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zfs_destroy' mangled-name='zfs_destroy' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_destroy'>
	- <parameter type-id='9200a744' name='zhp'/>
	- <parameter type-id='c19b74c3' name='defer'/>
	+ <function-decl name='lzc_wait_fs' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='3024501a'/>
	+ <parameter type-id='37e3bd22'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zfs_destroy_snaps_nvl' mangled-name='zfs_destroy_snaps_nvl' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_destroy_snaps_nvl'>
	- <parameter type-id='b0382bb3' name='hdl'/>
	- <parameter type-id='5ce45b60' name='snaps'/>
	- <parameter type-id='c19b74c3' name='defer'/>
	+ <function-decl name='zfs_error_fmt' mangled-name='zfs_error_fmt' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_error_fmt'>
	+ <parameter type-id='b0382bb3'/>
	+ <parameter type-id='95e97e5e'/>
	+ <parameter type-id='80f4b756'/>
	+ <parameter is-variadic='yes'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zfs_destroy_snaps' mangled-name='zfs_destroy_snaps' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_destroy_snaps'>
	- <parameter type-id='9200a744' name='zhp'/>
	- <parameter type-id='26a90f95' name='snapname'/>
	- <parameter type-id='c19b74c3' name='defer'/>
	+ <function-decl name='zfs_standard_error_fmt' mangled-name='zfs_standard_error_fmt' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_standard_error_fmt'>
	+ <parameter type-id='b0382bb3'/>
	+ <parameter type-id='95e97e5e'/>
	+ <parameter type-id='80f4b756'/>
	+ <parameter is-variadic='yes'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zfs_promote' mangled-name='zfs_promote' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_promote'>
	- <parameter type-id='9200a744' name='zhp'/>
	- <return type-id='95e97e5e'/>
	+ <function-decl name='zfs_setprop_error' mangled-name='zfs_setprop_error' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_setprop_error'>
	+ <parameter type-id='b0382bb3'/>
	+ <parameter type-id='58603c44'/>
	+ <parameter type-id='95e97e5e'/>
	+ <parameter type-id='26a90f95'/>
	+ <return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='zfs_snapshot_nvl' mangled-name='zfs_snapshot_nvl' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_snapshot_nvl'>
	- <parameter type-id='b0382bb3' name='hdl'/>
	- <parameter type-id='5ce45b60' name='snaps'/>
	- <parameter type-id='5ce45b60' name='props'/>
	+ <function-decl name='zprop_parse_value' mangled-name='zprop_parse_value' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zprop_parse_value'>
	+ <parameter type-id='b0382bb3'/>
	+ <parameter type-id='3fa542f0'/>
	+ <parameter type-id='95e97e5e'/>
	+ <parameter type-id='2e45de5d'/>
	+ <parameter type-id='5ce45b60'/>
	+ <parameter type-id='9b23c9ad'/>
	+ <parameter type-id='5d6479ae'/>
	+ <parameter type-id='80f4b756'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zfs_snapshot' mangled-name='zfs_snapshot' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_snapshot'>
	- <parameter type-id='b0382bb3' name='hdl'/>
	- <parameter type-id='80f4b756' name='path'/>
	- <parameter type-id='c19b74c3' name='recursive'/>
	- <parameter type-id='5ce45b60' name='props'/>
	+ <function-decl name='zprop_expand_list' mangled-name='zprop_expand_list' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zprop_expand_list'>
	+ <parameter type-id='b0382bb3'/>
	+ <parameter type-id='e4378506'/>
	+ <parameter type-id='2e45de5d'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zfs_rename' mangled-name='zfs_rename' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_rename'>
	- <parameter type-id='9200a744' name='zhp'/>
	- <parameter type-id='80f4b756' name='target'/>
	- <parameter type-id='067170c2' name='flags'/>
	+ <function-decl name='zcmd_write_src_nvlist' mangled-name='zcmd_write_src_nvlist' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zcmd_write_src_nvlist'>
	+ <parameter type-id='b0382bb3'/>
	+ <parameter type-id='e4ec4540'/>
	+ <parameter type-id='5ce45b60'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zfs_get_all_props' mangled-name='zfs_get_all_props' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_get_all_props'>
	- <parameter type-id='9200a744' name='zhp'/>
	- <return type-id='5ce45b60'/>
	- </function-decl>
	- <function-decl name='zfs_get_recvd_props' mangled-name='zfs_get_recvd_props' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_get_recvd_props'>
	- <parameter type-id='9200a744' name='zhp'/>
	- <return type-id='5ce45b60'/>
	- </function-decl>
	- <function-decl name='zfs_get_user_props' mangled-name='zfs_get_user_props' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_get_user_props'>
	- <parameter type-id='9200a744' name='zhp'/>
	- <return type-id='5ce45b60'/>
	+ <function-decl name='zpool_name_valid' mangled-name='zpool_name_valid' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_name_valid'>
	+ <parameter type-id='b0382bb3'/>
	+ <parameter type-id='c19b74c3'/>
	+ <parameter type-id='80f4b756'/>
	+ <return type-id='c19b74c3'/>
	</function-decl>
	- <function-decl name='zfs_expand_proplist' mangled-name='zfs_expand_proplist' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_expand_proplist'>
	- <parameter type-id='9200a744' name='zhp'/>
	- <parameter type-id='e4378506' name='plp'/>
	- <parameter type-id='c19b74c3' name='received'/>
	- <parameter type-id='c19b74c3' name='literal'/>
	+ <function-decl name='zfs_parse_options' mangled-name='zfs_parse_options' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_parse_options'>
	+ <parameter type-id='26a90f95'/>
	+ <parameter type-id='a7913f77'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zfs_prune_proplist' mangled-name='zfs_prune_proplist' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prune_proplist'>
	- <parameter type-id='9200a744' name='zhp'/>
	- <parameter type-id='ae3e8ca6' name='props'/>
	+ <function-decl name='zfs_nicebytes' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='9c313c2d'/>
	+ <parameter type-id='26a90f95'/>
	+ <parameter type-id='b59d7dce'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='zfs_smb_acl_add' mangled-name='zfs_smb_acl_add' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_smb_acl_add'>
	- <parameter type-id='b0382bb3' name='hdl'/>
	- <parameter type-id='26a90f95' name='dataset'/>
	- <parameter type-id='26a90f95' name='path'/>
	- <parameter type-id='26a90f95' name='resource'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='zfs_smb_acl_remove' mangled-name='zfs_smb_acl_remove' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_smb_acl_remove'>
	- <parameter type-id='b0382bb3' name='hdl'/>
	- <parameter type-id='26a90f95' name='dataset'/>
	- <parameter type-id='26a90f95' name='path'/>
	- <parameter type-id='26a90f95' name='resource'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='zfs_smb_acl_purge' mangled-name='zfs_smb_acl_purge' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_smb_acl_purge'>
	- <parameter type-id='b0382bb3' name='hdl'/>
	- <parameter type-id='26a90f95' name='dataset'/>
	- <parameter type-id='26a90f95' name='path'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='zfs_smb_acl_rename' mangled-name='zfs_smb_acl_rename' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_smb_acl_rename'>
	- <parameter type-id='b0382bb3' name='hdl'/>
	- <parameter type-id='26a90f95' name='dataset'/>
	- <parameter type-id='26a90f95' name='path'/>
	- <parameter type-id='26a90f95' name='oldname'/>
	- <parameter type-id='26a90f95' name='newname'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='zfs_userspace' mangled-name='zfs_userspace' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_userspace'>
	- <parameter type-id='9200a744' name='zhp'/>
	- <parameter type-id='279fde6a' name='type'/>
	- <parameter type-id='16c5f410' name='func'/>
	- <parameter type-id='eaa32e2f' name='arg'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='zfs_hold_nvl' mangled-name='zfs_hold_nvl' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_hold_nvl'>
	- <parameter type-id='9200a744' name='zhp'/>
	- <parameter type-id='95e97e5e' name='cleanup_fd'/>
	- <parameter type-id='5ce45b60' name='holds'/>
	- <return type-id='95e97e5e'/>
	+ <function-decl name='zfs_nicenum' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='9c313c2d'/>
	+ <parameter type-id='26a90f95'/>
	+ <parameter type-id='b59d7dce'/>
	+ <return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='zfs_hold' mangled-name='zfs_hold' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_hold'>
	- <parameter type-id='9200a744' name='zhp'/>
	- <parameter type-id='80f4b756' name='snapname'/>
	- <parameter type-id='80f4b756' name='tag'/>
	- <parameter type-id='c19b74c3' name='recursive'/>
	- <parameter type-id='95e97e5e' name='cleanup_fd'/>
	- <return type-id='95e97e5e'/>
	+ <function-decl name='avl_create' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='a3681dea'/>
	+ <parameter type-id='585e1de9'/>
	+ <parameter type-id='b59d7dce'/>
	+ <parameter type-id='b59d7dce'/>
	+ <return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='zfs_release' mangled-name='zfs_release' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_release'>
	- <parameter type-id='9200a744' name='zhp'/>
	- <parameter type-id='80f4b756' name='snapname'/>
	- <parameter type-id='80f4b756' name='tag'/>
	- <parameter type-id='c19b74c3' name='recursive'/>
	- <return type-id='95e97e5e'/>
	+ <function-decl name='avl_find' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='a3681dea'/>
	+ <parameter type-id='eaa32e2f'/>
	+ <parameter type-id='32adbf30'/>
	+ <return type-id='eaa32e2f'/>
	</function-decl>
	- <function-decl name='zfs_get_fsacl' mangled-name='zfs_get_fsacl' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_get_fsacl'>
	- <parameter type-id='9200a744' name='zhp'/>
	- <parameter type-id='857bb57e' name='nvl'/>
	- <return type-id='95e97e5e'/>
	+ <function-decl name='avl_add' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='a3681dea'/>
	+ <parameter type-id='eaa32e2f'/>
	+ <return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='zfs_set_fsacl' mangled-name='zfs_set_fsacl' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_set_fsacl'>
	- <parameter type-id='9200a744' name='zhp'/>
	- <parameter type-id='c19b74c3' name='un'/>
	- <parameter type-id='5ce45b60' name='nvl'/>
	- <return type-id='95e97e5e'/>
	+ <function-decl name='avl_remove' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='a3681dea'/>
	+ <parameter type-id='eaa32e2f'/>
	+ <return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='zfs_get_holds' mangled-name='zfs_get_holds' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_get_holds'>
	- <parameter type-id='9200a744' name='zhp'/>
	- <parameter type-id='857bb57e' name='nvl'/>
	- <return type-id='95e97e5e'/>
	+ <function-decl name='avl_numnodes' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='a3681dea'/>
	+ <return type-id='ee1f298e'/>
	</function-decl>
	- <function-decl name='zvol_volsize_to_reservation' mangled-name='zvol_volsize_to_reservation' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zvol_volsize_to_reservation'>
	- <parameter type-id='4c81de99' name='zph'/>
	- <parameter type-id='9c313c2d' name='volsize'/>
	- <parameter type-id='5ce45b60' name='props'/>
	- <return type-id='9c313c2d'/>
	+ <function-decl name='avl_destroy_nodes' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='a3681dea'/>
	+ <parameter type-id='63e171df'/>
	+ <return type-id='eaa32e2f'/>
	</function-decl>
	- <function-decl name='zfs_prop_set_list' mangled-name='zfs_prop_set_list' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_set_list'>
	- <parameter type-id='9200a744' name='zhp'/>
	- <parameter type-id='5ce45b60' name='props'/>
	- <return type-id='95e97e5e'/>
	+ <function-decl name='avl_destroy' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='a3681dea'/>
	+ <return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='zfs_prop_set' mangled-name='zfs_prop_set' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_set'>
	- <parameter type-id='9200a744' name='zhp'/>
	- <parameter type-id='80f4b756' name='propname'/>
	- <parameter type-id='80f4b756' name='propval'/>
	- <return type-id='95e97e5e'/>
	+ <function-decl name='zfs_prop_readonly' mangled-name='zfs_prop_readonly' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_readonly'>
	+ <parameter type-id='58603c44'/>
	+ <return type-id='c19b74c3'/>
	</function-decl>
	- <function-decl name='zfs_rollback' mangled-name='zfs_rollback' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_rollback'>
	- <parameter type-id='9200a744' name='zhp'/>
	- <parameter type-id='9200a744' name='snap'/>
	- <parameter type-id='c19b74c3' name='force'/>
	- <return type-id='95e97e5e'/>
	+ <function-decl name='zfs_prop_inheritable' mangled-name='zfs_prop_inheritable' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_inheritable'>
	+ <parameter type-id='58603c44'/>
	+ <return type-id='c19b74c3'/>
	</function-decl>
	- <function-decl name='zfs_clone' mangled-name='zfs_clone' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_clone'>
	- <parameter type-id='9200a744' name='zhp'/>
	- <parameter type-id='80f4b756' name='target'/>
	- <parameter type-id='5ce45b60' name='props'/>
	- <return type-id='95e97e5e'/>
	+ <function-decl name='zfs_prop_setonce' mangled-name='zfs_prop_setonce' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_setonce'>
	+ <parameter type-id='58603c44'/>
	+ <return type-id='c19b74c3'/>
	</function-decl>
	- <function-decl name='zfs_wait_status' mangled-name='zfs_wait_status' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_wait_status'>
	- <parameter type-id='9200a744' name='zhp'/>
	- <parameter type-id='3024501a' name='activity'/>
	- <parameter type-id='37e3bd22' name='missing'/>
	- <parameter type-id='37e3bd22' name='waited'/>
	- <return type-id='95e97e5e'/>
	+ <function-decl name='zfs_prop_encryption_key_param' mangled-name='zfs_prop_encryption_key_param' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_encryption_key_param'>
	+ <parameter type-id='58603c44'/>
	+ <return type-id='c19b74c3'/>
	</function-decl>
	- <function-decl name='nvlist_lookup_int64' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='5ce45b60'/>
	+ <function-decl name='zfs_prop_valid_keylocation' mangled-name='zfs_prop_valid_keylocation' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_valid_keylocation'>
	<parameter type-id='80f4b756'/>
	- <parameter type-id='cb785ebf'/>
	- <return type-id='95e97e5e'/>
	+ <parameter type-id='c19b74c3'/>
	+ <return type-id='c19b74c3'/>
	</function-decl>
	- <function-decl name='fprintf' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='822cd80b'/>
	+ <function-decl name='zfs_prop_user' mangled-name='zfs_prop_user' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_user'>
	<parameter type-id='80f4b756'/>
	- <parameter is-variadic='yes'/>
	- <return type-id='95e97e5e'/>
	+ <return type-id='c19b74c3'/>
	</function-decl>
	- <function-decl name='fnvlist_add_string' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='5ce45b60'/>
	- <parameter type-id='80f4b756'/>
	+ <function-decl name='zfs_prop_userquota' mangled-name='zfs_prop_userquota' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_userquota'>
	<parameter type-id='80f4b756'/>
	- <return type-id='48b5725f'/>
	+ <return type-id='c19b74c3'/>
	</function-decl>
	- <function-decl name='lzc_channel_program_nosync' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='80f4b756'/>
	+ <function-decl name='zfs_prop_written' mangled-name='zfs_prop_written' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_written'>
	<parameter type-id='80f4b756'/>
	+ <return type-id='c19b74c3'/>
	+ </function-decl>
	+ <function-decl name='zfs_prop_index_to_string' mangled-name='zfs_prop_index_to_string' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_index_to_string'>
	+ <parameter type-id='58603c44'/>
	<parameter type-id='9c313c2d'/>
	- <parameter type-id='9c313c2d'/>
	- <parameter type-id='5ce45b60'/>
	- <parameter type-id='857bb57e'/>
	+ <parameter type-id='7d3cd834'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='fnvlist_lookup_nvlist' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='5ce45b60'/>
	- <parameter type-id='80f4b756'/>
	- <return type-id='5ce45b60'/>
	+ <function-decl name='zfs_prop_valid_for_type' mangled-name='zfs_prop_valid_for_type' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_valid_for_type'>
	+ <parameter type-id='95e97e5e'/>
	+ <parameter type-id='2e45de5d'/>
	+ <parameter type-id='c19b74c3'/>
	+ <return type-id='c19b74c3'/>
	</function-decl>
	- <function-decl name='zfs_prop_get_type' mangled-name='zfs_prop_get_type' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_get_type'>
	- <parameter type-id='58603c44'/>
	- <return type-id='31429eff'/>
	+ <function-decl name='nvlist_alloc' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='857bb57e'/>
	+ <parameter type-id='3502e3ff'/>
	+ <parameter type-id='95e97e5e'/>
	+ <return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='strrchr' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='80f4b756'/>
	+ <function-decl name='nvlist_size' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='5ce45b60'/>
	+ <parameter type-id='78c01427'/>
	<parameter type-id='95e97e5e'/>
	- <return type-id='26a90f95'/>
	+ <return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='ioctl' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='nvlist_pack' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='5ce45b60'/>
	+ <parameter type-id='9b23c9ad'/>
	+ <parameter type-id='78c01427'/>
	+ <parameter type-id='95e97e5e'/>
	<parameter type-id='95e97e5e'/>
	- <parameter type-id='7359adad'/>
	- <parameter is-variadic='yes'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='nvlist_alloc' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='nvlist_unpack' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='26a90f95'/>
	+ <parameter type-id='b59d7dce'/>
	<parameter type-id='857bb57e'/>
	- <parameter type-id='3502e3ff'/>
	<parameter type-id='95e97e5e'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zcmd_write_src_nvlist' mangled-name='zcmd_write_src_nvlist' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zcmd_write_src_nvlist'>
	- <parameter type-id='b0382bb3'/>
	- <parameter type-id='e4ec4540'/>
	+ <function-decl name='nvlist_add_boolean' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='5ce45b60'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='zfs_prop_user' mangled-name='zfs_prop_user' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_user'>
	<parameter type-id='80f4b756'/>
	- <return type-id='c19b74c3'/>
	+ <return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='nvlist_add_nvlist' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='5ce45b60'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zpool_get_name' mangled-name='zpool_get_name' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_get_name'>
	- <parameter type-id='4c81de99'/>
	- <return type-id='80f4b756'/>
	- </function-decl>
	- <function-decl name='zpool_open_canfail' mangled-name='zpool_open_canfail' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_open_canfail'>
	- <parameter type-id='b0382bb3'/>
	- <parameter type-id='80f4b756'/>
	- <return type-id='4c81de99'/>
	- </function-decl>
	- <function-decl name='abort' visibility='default' binding='global' size-in-bits='64'>
	- <return type-id='48b5725f'/>
	- </function-decl>
	- <function-decl name='strtoul' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='nvlist_add_uint64_array' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	- <parameter type-id='9b23c9ad'/>
	- <parameter type-id='95e97e5e'/>
	- <return type-id='7359adad'/>
	+ <parameter type-id='5d6479ae'/>
	+ <parameter type-id='3502e3ff'/>
	+ <return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='getpwnam' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='nvlist_remove' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	- <return type-id='a195f4a3'/>
	+ <parameter type-id='8d0687d2'/>
	+ <return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='getgrnam' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='nvlist_remove_all' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	- <return type-id='566b3f52'/>
	- </function-decl>
	- <function-decl name='zfs_prop_default_string' mangled-name='zfs_prop_default_string' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_default_string'>
	- <parameter type-id='58603c44'/>
	- <return type-id='80f4b756'/>
	+ <return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='fnvlist_lookup_string' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='nvlist_lookup_int64' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	- <return type-id='26a90f95'/>
	+ <parameter type-id='cb785ebf'/>
	+ <return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='strstr' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='80f4b756'/>
	+ <function-decl name='nvlist_lookup_uint64_array' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	- <return type-id='26a90f95'/>
	+ <parameter type-id='892b4acc'/>
	+ <parameter type-id='4dd26a40'/>
	+ <return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='entity_namecheck' mangled-name='entity_namecheck' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='entity_namecheck'>
	+ <function-decl name='nvlist_lookup_nvlist_array' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	- <parameter type-id='053457bd'/>
	- <parameter type-id='26a90f95'/>
	+ <parameter type-id='75be733c'/>
	+ <parameter type-id='4dd26a40'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zpool_name_valid' mangled-name='zpool_name_valid' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_name_valid'>
	- <parameter type-id='b0382bb3'/>
	- <parameter type-id='c19b74c3'/>
	- <parameter type-id='80f4b756'/>
	+ <function-decl name='nvlist_empty' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='5ce45b60'/>
	<return type-id='c19b74c3'/>
	</function-decl>
	- <function-decl name='zpool_close' mangled-name='zpool_close' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_close'>
	- <parameter type-id='4c81de99'/>
	- <return type-id='48b5725f'/>
	+ <function-decl name='nvpair_type' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='3fa542f0'/>
	+ <return type-id='8d0687d2'/>
	</function-decl>
	- <function-decl name='lzc_get_bookmarks' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='5ce45b60'/>
	- <parameter type-id='857bb57e'/>
	+ <function-decl name='nvpair_value_uint64' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='3fa542f0'/>
	+ <parameter type-id='5d6479ae'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zfs_iter_bookmarks' mangled-name='zfs_iter_bookmarks' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_iter_bookmarks'>
	- <parameter type-id='9200a744'/>
	- <parameter type-id='d8e49ab9'/>
	- <parameter type-id='eaa32e2f'/>
	+ <function-decl name='nvpair_value_string' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='3fa542f0'/>
	+ <parameter type-id='9b23c9ad'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='lzc_exists' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='fnvlist_free' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='5ce45b60'/>
	+ <return type-id='48b5725f'/>
	+ </function-decl>
	+ <function-decl name='fnvlist_add_boolean' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	- <return type-id='c19b74c3'/>
	+ <return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='nvlist_add_boolean' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='fnvlist_add_uint64' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	- <return type-id='95e97e5e'/>
	+ <parameter type-id='9c313c2d'/>
	+ <return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='fnvlist_add_boolean' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='fnvlist_add_string' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	+ <parameter type-id='80f4b756'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='fnvlist_add_nvlist' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='5ce45b60'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='fnvlist_free' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='fnvlist_lookup_string' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='5ce45b60'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	- <function-decl name='lzc_get_holds' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='80f4b756'/>
	- <parameter type-id='857bb57e'/>
	- <return type-id='95e97e5e'/>
	+ <return type-id='26a90f95'/>
	</function-decl>
	- <function-decl name='pthread_mutex_init' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='18c91f9e'/>
	- <parameter type-id='c2afbd7e'/>
	- <return type-id='95e97e5e'/>
	+ <function-decl name='fnvlist_lookup_nvlist' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='5ce45b60'/>
	+ <parameter type-id='80f4b756'/>
	+ <return type-id='5ce45b60'/>
	</function-decl>
	- <function-decl name='avl_create' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='a3681dea'/>
	- <parameter type-id='585e1de9'/>
	- <parameter type-id='b59d7dce'/>
	- <parameter type-id='b59d7dce'/>
	- <return type-id='48b5725f'/>
	+ <function-decl name='fnvpair_value_int32' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='3fa542f0'/>
	+ <return type-id='3ff5601b'/>
	</function-decl>
	- <function-decl name='avl_destroy_nodes' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='a3681dea'/>
	- <parameter type-id='63e171df'/>
	- <return type-id='eaa32e2f'/>
	+ <function-decl name='fnvpair_value_uint64' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='3fa542f0'/>
	+ <return type-id='9c313c2d'/>
	</function-decl>
	- <function-decl name='avl_destroy' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='a3681dea'/>
	- <return type-id='48b5725f'/>
	+ <function-decl name='entity_namecheck' mangled-name='entity_namecheck' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='entity_namecheck'>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='053457bd'/>
	+ <parameter type-id='26a90f95'/>
	+ <return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='pthread_mutex_destroy' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='18c91f9e'/>
	+ <function-decl name='dataset_nestcheck' mangled-name='dataset_nestcheck' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='dataset_nestcheck'>
	+ <parameter type-id='80f4b756'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='avl_numnodes' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='a3681dea'/>
	- <return type-id='ee1f298e'/>
	+ <function-decl name='mountpoint_namecheck' mangled-name='mountpoint_namecheck' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='mountpoint_namecheck'>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='053457bd'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='zfs_prop_get_type' mangled-name='zfs_prop_get_type' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_get_type'>
	+ <parameter type-id='58603c44'/>
	+ <return type-id='31429eff'/>
	</function-decl>
	<function-decl name='getmntany' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='822cd80b'/>
	<parameter type-id='9d424d31'/>
	<parameter type-id='9d424d31'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='avl_find' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='a3681dea'/>
	- <parameter type-id='eaa32e2f'/>
	- <parameter type-id='32adbf30'/>
	- <return type-id='eaa32e2f'/>
	- </function-decl>
	- <function-decl name='avl_add' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='a3681dea'/>
	- <parameter type-id='eaa32e2f'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	<function-decl name='_sol_getmntent' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='822cd80b'/>
	<parameter type-id='9d424d31'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='pthread_mutex_unlock' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='18c91f9e'/>
	+ <function-decl name='zfs_type_to_name' mangled-name='zfs_type_to_name' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_type_to_name'>
	+ <parameter type-id='2e45de5d' name='type'/>
	+ <return type-id='80f4b756'/>
	+ </function-decl>
	+ <function-decl name='zfs_validate_name' mangled-name='zfs_validate_name' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_validate_name'>
	+ <parameter type-id='b0382bb3' name='hdl'/>
	+ <parameter type-id='80f4b756' name='path'/>
	+ <parameter type-id='95e97e5e' name='type'/>
	+ <parameter type-id='c19b74c3' name='modifying'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='pthread_mutex_lock' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='18c91f9e'/>
	+ <function-decl name='zfs_name_valid' mangled-name='zfs_name_valid' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_name_valid'>
	+ <parameter type-id='80f4b756' name='name'/>
	+ <parameter type-id='2e45de5d' name='type'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='avl_remove' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='a3681dea'/>
	- <parameter type-id='eaa32e2f'/>
	+ <function-decl name='zpool_free_handles' mangled-name='zpool_free_handles' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_free_handles'>
	+ <parameter type-id='b0382bb3' name='hdl'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='zfs_prop_default_numeric' mangled-name='zfs_prop_default_numeric' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_default_numeric'>
	- <parameter type-id='58603c44'/>
	- <return type-id='9c313c2d'/>
	+ <function-decl name='make_dataset_handle_zc' mangled-name='make_dataset_handle_zc' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='make_dataset_handle_zc'>
	+ <parameter type-id='b0382bb3' name='hdl'/>
	+ <parameter type-id='e4ec4540' name='zc'/>
	+ <return type-id='9200a744'/>
	</function-decl>
	- <function-decl name='hasmntopt' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='48bea5ec'/>
	- <parameter type-id='80f4b756'/>
	- <return type-id='26a90f95'/>
	+ <function-decl name='make_dataset_simple_handle_zc' mangled-name='make_dataset_simple_handle_zc' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='make_dataset_simple_handle_zc'>
	+ <parameter type-id='9200a744' name='pzhp'/>
	+ <parameter type-id='e4ec4540' name='zc'/>
	+ <return type-id='9200a744'/>
	</function-decl>
	- <function-decl name='zfs_prop_valid_for_type' mangled-name='zfs_prop_valid_for_type' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_valid_for_type'>
	- <parameter type-id='95e97e5e'/>
	- <parameter type-id='2e45de5d'/>
	- <parameter type-id='c19b74c3'/>
	+ <function-decl name='zfs_bookmark_exists' mangled-name='zfs_bookmark_exists' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_bookmark_exists'>
	+ <parameter type-id='80f4b756' name='path'/>
	<return type-id='c19b74c3'/>
	</function-decl>
	- <function-decl name='zfs_prop_readonly' mangled-name='zfs_prop_readonly' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_readonly'>
	- <parameter type-id='58603c44'/>
	- <return type-id='c19b74c3'/>
	+ <function-decl name='make_bookmark_handle' mangled-name='make_bookmark_handle' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='make_bookmark_handle'>
	+ <parameter type-id='9200a744' name='parent'/>
	+ <parameter type-id='80f4b756' name='path'/>
	+ <parameter type-id='5ce45b60' name='bmark_props'/>
	+ <return type-id='9200a744'/>
	</function-decl>
	- <function-decl name='zfs_prop_setonce' mangled-name='zfs_prop_setonce' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_setonce'>
	- <parameter type-id='58603c44'/>
	- <return type-id='c19b74c3'/>
	+ <function-decl name='libzfs_mnttab_init' mangled-name='libzfs_mnttab_init' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libzfs_mnttab_init'>
	+ <parameter type-id='b0382bb3' name='hdl'/>
	+ <return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='mountpoint_namecheck' mangled-name='mountpoint_namecheck' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='mountpoint_namecheck'>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='053457bd'/>
	- <return type-id='95e97e5e'/>
	+ <function-decl name='libzfs_mnttab_fini' mangled-name='libzfs_mnttab_fini' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libzfs_mnttab_fini'>
	+ <parameter type-id='b0382bb3' name='hdl'/>
	+ <return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='zpool_prop_get_feature' mangled-name='zpool_prop_get_feature' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_prop_get_feature'>
	- <parameter type-id='4c81de99'/>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='26a90f95'/>
	- <parameter type-id='b59d7dce'/>
	+ <function-decl name='libzfs_mnttab_cache' mangled-name='libzfs_mnttab_cache' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libzfs_mnttab_cache'>
	+ <parameter type-id='b0382bb3' name='hdl'/>
	+ <parameter type-id='c19b74c3' name='enable'/>
	+ <return type-id='48b5725f'/>
	+ </function-decl>
	+ <function-decl name='libzfs_mnttab_find' mangled-name='libzfs_mnttab_find' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libzfs_mnttab_find'>
	+ <parameter type-id='b0382bb3' name='hdl'/>
	+ <parameter type-id='80f4b756' name='fsname'/>
	+ <parameter type-id='9d424d31' name='entry'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zfs_nicebytes' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='9c313c2d'/>
	- <parameter type-id='26a90f95'/>
	- <parameter type-id='b59d7dce'/>
	+ <function-decl name='libzfs_mnttab_add' mangled-name='libzfs_mnttab_add' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libzfs_mnttab_add'>
	+ <parameter type-id='b0382bb3' name='hdl'/>
	+ <parameter type-id='80f4b756' name='special'/>
	+ <parameter type-id='80f4b756' name='mountp'/>
	+ <parameter type-id='80f4b756' name='mntopts'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='zfs_parse_options' mangled-name='zfs_parse_options' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_parse_options'>
	- <parameter type-id='26a90f95'/>
	- <parameter type-id='a7913f77'/>
	+ <function-decl name='libzfs_mnttab_remove' mangled-name='libzfs_mnttab_remove' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libzfs_mnttab_remove'>
	+ <parameter type-id='b0382bb3' name='hdl'/>
	+ <parameter type-id='80f4b756' name='fsname'/>
	+ <return type-id='48b5725f'/>
	+ </function-decl>
	+ <function-decl name='zfs_spa_version' mangled-name='zfs_spa_version' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_spa_version'>
	+ <parameter type-id='9200a744' name='zhp'/>
	+ <parameter type-id='7292109c' name='spa_version'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='nvpair_type' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='3fa542f0'/>
	- <return type-id='8d0687d2'/>
	+ <function-decl name='zfs_prop_set' mangled-name='zfs_prop_set' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_set'>
	+ <parameter type-id='9200a744' name='zhp'/>
	+ <parameter type-id='80f4b756' name='propname'/>
	+ <parameter type-id='80f4b756' name='propval'/>
	+ <return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='nvpair_value_uint64' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='3fa542f0'/>
	- <parameter type-id='5d6479ae'/>
	+ <function-decl name='zfs_prop_set_list' mangled-name='zfs_prop_set_list' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_set_list'>
	+ <parameter type-id='9200a744' name='zhp'/>
	+ <parameter type-id='5ce45b60' name='props'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='asprintf' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='9b23c9ad'/>
	- <parameter type-id='80f4b756'/>
	- <parameter is-variadic='yes'/>
	+ <function-decl name='zfs_prop_inherit' mangled-name='zfs_prop_inherit' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_inherit'>
	+ <parameter type-id='9200a744' name='zhp'/>
	+ <parameter type-id='80f4b756' name='propname'/>
	+ <parameter type-id='c19b74c3' name='received'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='nvlist_add_uint64_array' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='5ce45b60'/>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='5d6479ae'/>
	- <parameter type-id='3502e3ff'/>
	+ <function-decl name='getprop_uint64' mangled-name='getprop_uint64' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='getprop_uint64'>
	+ <parameter type-id='9200a744' name='zhp'/>
	+ <parameter type-id='58603c44' name='prop'/>
	+ <parameter type-id='9b23c9ad' name='source'/>
	+ <return type-id='9c313c2d'/>
	+ </function-decl>
	+ <function-decl name='zfs_prop_get_recvd' mangled-name='zfs_prop_get_recvd' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_get_recvd'>
	+ <parameter type-id='9200a744' name='zhp'/>
	+ <parameter type-id='80f4b756' name='propname'/>
	+ <parameter type-id='26a90f95' name='propbuf'/>
	+ <parameter type-id='b59d7dce' name='proplen'/>
	+ <parameter type-id='c19b74c3' name='literal'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='nvpair_value_string' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='3fa542f0'/>
	- <parameter type-id='9b23c9ad'/>
	+ <function-decl name='zfs_get_clones_nvl' mangled-name='zfs_get_clones_nvl' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_get_clones_nvl'>
	+ <parameter type-id='9200a744' name='zhp'/>
	+ <return type-id='5ce45b60'/>
	+ </function-decl>
	+ <function-decl name='zfs_prop_get_numeric' mangled-name='zfs_prop_get_numeric' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_get_numeric'>
	+ <parameter type-id='9200a744' name='zhp'/>
	+ <parameter type-id='58603c44' name='prop'/>
	+ <parameter type-id='5d6479ae' name='value'/>
	+ <parameter type-id='debc6aa3' name='src'/>
	+ <parameter type-id='26a90f95' name='statbuf'/>
	+ <parameter type-id='b59d7dce' name='statlen'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zfs_nicestrtonum' mangled-name='zfs_nicestrtonum' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_nicestrtonum'>
	- <parameter type-id='b0382bb3'/>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='5d6479ae'/>
	+ <function-decl name='zfs_prop_get_userquota_int' mangled-name='zfs_prop_get_userquota_int' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_get_userquota_int'>
	+ <parameter type-id='9200a744' name='zhp'/>
	+ <parameter type-id='80f4b756' name='propname'/>
	+ <parameter type-id='5d6479ae' name='propvalue'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zfs_prop_encryption_key_param' mangled-name='zfs_prop_encryption_key_param' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_encryption_key_param'>
	- <parameter type-id='58603c44'/>
	- <return type-id='c19b74c3'/>
	+ <function-decl name='zfs_prop_get_userquota' mangled-name='zfs_prop_get_userquota' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_get_userquota'>
	+ <parameter type-id='9200a744' name='zhp'/>
	+ <parameter type-id='80f4b756' name='propname'/>
	+ <parameter type-id='26a90f95' name='propbuf'/>
	+ <parameter type-id='95e97e5e' name='proplen'/>
	+ <parameter type-id='c19b74c3' name='literal'/>
	+ <return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zprop_parse_value' mangled-name='zprop_parse_value' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zprop_parse_value'>
	- <parameter type-id='b0382bb3'/>
	- <parameter type-id='3fa542f0'/>
	- <parameter type-id='95e97e5e'/>
	- <parameter type-id='2e45de5d'/>
	- <parameter type-id='5ce45b60'/>
	- <parameter type-id='9b23c9ad'/>
	- <parameter type-id='5d6479ae'/>
	- <parameter type-id='80f4b756'/>
	+ <function-decl name='zfs_prop_get_written_int' mangled-name='zfs_prop_get_written_int' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_get_written_int'>
	+ <parameter type-id='9200a744' name='zhp'/>
	+ <parameter type-id='80f4b756' name='propname'/>
	+ <parameter type-id='5d6479ae' name='propvalue'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zfs_prop_userquota' mangled-name='zfs_prop_userquota' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_userquota'>
	- <parameter type-id='80f4b756'/>
	- <return type-id='c19b74c3'/>
	+ <function-decl name='zfs_prop_get_written' mangled-name='zfs_prop_get_written' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_get_written'>
	+ <parameter type-id='9200a744' name='zhp'/>
	+ <parameter type-id='80f4b756' name='propname'/>
	+ <parameter type-id='26a90f95' name='propbuf'/>
	+ <parameter type-id='95e97e5e' name='proplen'/>
	+ <parameter type-id='c19b74c3' name='literal'/>
	+ <return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zfs_prop_written' mangled-name='zfs_prop_written' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_written'>
	- <parameter type-id='80f4b756'/>
	- <return type-id='c19b74c3'/>
	+ <function-decl name='zfs_get_pool_name' mangled-name='zfs_get_pool_name' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_get_pool_name'>
	+ <parameter type-id='fcd57163' name='zhp'/>
	+ <return type-id='80f4b756'/>
	</function-decl>
	- <function-decl name='zfs_prop_valid_keylocation' mangled-name='zfs_prop_valid_keylocation' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_valid_keylocation'>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='c19b74c3'/>
	- <return type-id='c19b74c3'/>
	+ <function-decl name='zfs_get_type' mangled-name='zfs_get_type' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_get_type'>
	+ <parameter type-id='fcd57163' name='zhp'/>
	+ <return type-id='2e45de5d'/>
	</function-decl>
	- <function-decl name='zfs_prop_inheritable' mangled-name='zfs_prop_inheritable' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_inheritable'>
	- <parameter type-id='58603c44'/>
	+ <function-decl name='zfs_dataset_exists' mangled-name='zfs_dataset_exists' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_dataset_exists'>
	+ <parameter type-id='b0382bb3' name='hdl'/>
	+ <parameter type-id='80f4b756' name='path'/>
	+ <parameter type-id='2e45de5d' name='types'/>
	<return type-id='c19b74c3'/>
	</function-decl>
	- <function-decl name='zfs_error_fmt' mangled-name='zfs_error_fmt' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_error_fmt'>
	- <parameter type-id='b0382bb3'/>
	- <parameter type-id='95e97e5e'/>
	- <parameter type-id='80f4b756'/>
	- <parameter is-variadic='yes'/>
	+ <function-decl name='create_parents' mangled-name='create_parents' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='create_parents'>
	+ <parameter type-id='b0382bb3' name='hdl'/>
	+ <parameter type-id='26a90f95' name='target'/>
	+ <parameter type-id='95e97e5e' name='prefixlen'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zfs_nicenum' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='9c313c2d'/>
	- <parameter type-id='26a90f95'/>
	- <parameter type-id='b59d7dce'/>
	- <return type-id='48b5725f'/>
	+ <function-decl name='zfs_create_ancestors' mangled-name='zfs_create_ancestors' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_create_ancestors'>
	+ <parameter type-id='b0382bb3' name='hdl'/>
	+ <parameter type-id='80f4b756' name='path'/>
	+ <return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='nvlist_lookup_uint64_array' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='5ce45b60'/>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='892b4acc'/>
	- <parameter type-id='4dd26a40'/>
	+ <function-decl name='zfs_create' mangled-name='zfs_create' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_create'>
	+ <parameter type-id='b0382bb3' name='hdl'/>
	+ <parameter type-id='80f4b756' name='path'/>
	+ <parameter type-id='2e45de5d' name='type'/>
	+ <parameter type-id='5ce45b60' name='props'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='zfs_destroy' mangled-name='zfs_destroy' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_destroy'>
	+ <parameter type-id='9200a744' name='zhp'/>
	+ <parameter type-id='c19b74c3' name='defer'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='localtime_r' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='9f201474'/>
	- <parameter type-id='d915a820'/>
	- <return type-id='d915a820'/>
	+ <function-decl name='zfs_destroy_snaps' mangled-name='zfs_destroy_snaps' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_destroy_snaps'>
	+ <parameter type-id='9200a744' name='zhp'/>
	+ <parameter type-id='26a90f95' name='snapname'/>
	+ <parameter type-id='c19b74c3' name='defer'/>
	+ <return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='strftime' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='26a90f95'/>
	- <parameter type-id='b59d7dce'/>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='d6ad37ff'/>
	- <return type-id='b59d7dce'/>
	+ <function-decl name='zfs_destroy_snaps_nvl' mangled-name='zfs_destroy_snaps_nvl' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_destroy_snaps_nvl'>
	+ <parameter type-id='b0382bb3' name='hdl'/>
	+ <parameter type-id='5ce45b60' name='snaps'/>
	+ <parameter type-id='c19b74c3' name='defer'/>
	+ <return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='nvlist_empty' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='5ce45b60'/>
	- <return type-id='c19b74c3'/>
	+ <function-decl name='zfs_clone' mangled-name='zfs_clone' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_clone'>
	+ <parameter type-id='9200a744' name='zhp'/>
	+ <parameter type-id='80f4b756' name='target'/>
	+ <parameter type-id='5ce45b60' name='props'/>
	+ <return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zpool_get_prop' mangled-name='zpool_get_prop' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_get_prop'>
	- <parameter type-id='4c81de99'/>
	- <parameter type-id='5d0c23fb'/>
	- <parameter type-id='26a90f95'/>
	- <parameter type-id='b59d7dce'/>
	- <parameter type-id='debc6aa3'/>
	- <parameter type-id='c19b74c3'/>
	+ <function-decl name='zfs_promote' mangled-name='zfs_promote' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_promote'>
	+ <parameter type-id='9200a744' name='zhp'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zfs_prop_index_to_string' mangled-name='zfs_prop_index_to_string' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_index_to_string'>
	- <parameter type-id='58603c44'/>
	- <parameter type-id='9c313c2d'/>
	- <parameter type-id='7d3cd834'/>
	+ <function-decl name='zfs_snapshot_nvl' mangled-name='zfs_snapshot_nvl' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_snapshot_nvl'>
	+ <parameter type-id='b0382bb3' name='hdl'/>
	+ <parameter type-id='5ce45b60' name='snaps'/>
	+ <parameter type-id='5ce45b60' name='props'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='dataset_nestcheck' mangled-name='dataset_nestcheck' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='dataset_nestcheck'>
	- <parameter type-id='80f4b756'/>
	+ <function-decl name='zfs_snapshot' mangled-name='zfs_snapshot' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_snapshot'>
	+ <parameter type-id='b0382bb3' name='hdl'/>
	+ <parameter type-id='80f4b756' name='path'/>
	+ <parameter type-id='c19b74c3' name='recursive'/>
	+ <parameter type-id='5ce45b60' name='props'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zpool_open' mangled-name='zpool_open' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_open'>
	- <parameter type-id='b0382bb3'/>
	- <parameter type-id='80f4b756'/>
	- <return type-id='4c81de99'/>
	+ <function-decl name='zfs_rollback' mangled-name='zfs_rollback' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_rollback'>
	+ <parameter type-id='9200a744' name='zhp'/>
	+ <parameter type-id='9200a744' name='snap'/>
	+ <parameter type-id='c19b74c3' name='force'/>
	+ <return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='lzc_create' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='bc9887f1'/>
	- <parameter type-id='5ce45b60'/>
	- <parameter type-id='ae3e8ca6'/>
	- <parameter type-id='3502e3ff'/>
	+ <function-decl name='zfs_rename' mangled-name='zfs_rename' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_rename'>
	+ <parameter type-id='9200a744' name='zhp'/>
	+ <parameter type-id='80f4b756' name='target'/>
	+ <parameter type-id='067170c2' name='flags'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zfs_share' mangled-name='zfs_share' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_share'>
	- <parameter type-id='9200a744'/>
	+ <function-decl name='zfs_get_all_props' mangled-name='zfs_get_all_props' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_get_all_props'>
	+ <parameter type-id='9200a744' name='zhp'/>
	+ <return type-id='5ce45b60'/>
	+ </function-decl>
	+ <function-decl name='zfs_get_recvd_props' mangled-name='zfs_get_recvd_props' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_get_recvd_props'>
	+ <parameter type-id='9200a744' name='zhp'/>
	+ <return type-id='5ce45b60'/>
	+ </function-decl>
	+ <function-decl name='zfs_get_user_props' mangled-name='zfs_get_user_props' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_get_user_props'>
	+ <parameter type-id='9200a744' name='zhp'/>
	+ <return type-id='5ce45b60'/>
	+ </function-decl>
	+ <function-decl name='zfs_expand_proplist' mangled-name='zfs_expand_proplist' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_expand_proplist'>
	+ <parameter type-id='9200a744' name='zhp'/>
	+ <parameter type-id='e4378506' name='plp'/>
	+ <parameter type-id='c19b74c3' name='received'/>
	+ <parameter type-id='c19b74c3' name='literal'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zfs_commit_all_shares' mangled-name='zfs_commit_all_shares' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_commit_all_shares'>
	+ <function-decl name='zfs_prune_proplist' mangled-name='zfs_prune_proplist' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prune_proplist'>
	+ <parameter type-id='9200a744' name='zhp'/>
	+ <parameter type-id='ae3e8ca6' name='props'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='__strdup' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='80f4b756'/>
	- <return type-id='26a90f95'/>
	+ <function-decl name='zfs_smb_acl_add' mangled-name='zfs_smb_acl_add' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_smb_acl_add'>
	+ <parameter type-id='b0382bb3' name='hdl'/>
	+ <parameter type-id='26a90f95' name='dataset'/>
	+ <parameter type-id='26a90f95' name='path'/>
	+ <parameter type-id='26a90f95' name='resource'/>
	+ <return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='lzc_destroy_bookmarks' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='5ce45b60'/>
	- <parameter type-id='857bb57e'/>
	+ <function-decl name='zfs_smb_acl_remove' mangled-name='zfs_smb_acl_remove' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_smb_acl_remove'>
	+ <parameter type-id='b0382bb3' name='hdl'/>
	+ <parameter type-id='26a90f95' name='dataset'/>
	+ <parameter type-id='26a90f95' name='path'/>
	+ <parameter type-id='26a90f95' name='resource'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='lzc_destroy_snaps' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='5ce45b60'/>
	- <parameter type-id='c19b74c3'/>
	- <parameter type-id='857bb57e'/>
	+ <function-decl name='zfs_smb_acl_purge' mangled-name='zfs_smb_acl_purge' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_smb_acl_purge'>
	+ <parameter type-id='b0382bb3' name='hdl'/>
	+ <parameter type-id='26a90f95' name='dataset'/>
	+ <parameter type-id='26a90f95' name='path'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='lzc_destroy' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='80f4b756'/>
	+ <function-decl name='zfs_smb_acl_rename' mangled-name='zfs_smb_acl_rename' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_smb_acl_rename'>
	+ <parameter type-id='b0382bb3' name='hdl'/>
	+ <parameter type-id='26a90f95' name='dataset'/>
	+ <parameter type-id='26a90f95' name='path'/>
	+ <parameter type-id='26a90f95' name='oldname'/>
	+ <parameter type-id='26a90f95' name='newname'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zfs_standard_error_fmt' mangled-name='zfs_standard_error_fmt' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_standard_error_fmt'>
	- <parameter type-id='b0382bb3'/>
	- <parameter type-id='95e97e5e'/>
	- <parameter type-id='80f4b756'/>
	- <parameter is-variadic='yes'/>
	+ <function-decl name='zfs_userspace' mangled-name='zfs_userspace' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_userspace'>
	+ <parameter type-id='9200a744' name='zhp'/>
	+ <parameter type-id='279fde6a' name='type'/>
	+ <parameter type-id='16c5f410' name='func'/>
	+ <parameter type-id='eaa32e2f' name='arg'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='fnvpair_value_int32' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='3fa542f0'/>
	- <return type-id='3ff5601b'/>
	+ <function-decl name='zfs_hold' mangled-name='zfs_hold' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_hold'>
	+ <parameter type-id='9200a744' name='zhp'/>
	+ <parameter type-id='80f4b756' name='snapname'/>
	+ <parameter type-id='80f4b756' name='tag'/>
	+ <parameter type-id='c19b74c3' name='recursive'/>
	+ <parameter type-id='95e97e5e' name='cleanup_fd'/>
	+ <return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='lzc_promote' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='26a90f95'/>
	- <parameter type-id='95e97e5e'/>
	+ <function-decl name='zfs_hold_nvl' mangled-name='zfs_hold_nvl' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_hold_nvl'>
	+ <parameter type-id='9200a744' name='zhp'/>
	+ <parameter type-id='95e97e5e' name='cleanup_fd'/>
	+ <parameter type-id='5ce45b60' name='holds'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='lzc_snapshot' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='5ce45b60'/>
	- <parameter type-id='5ce45b60'/>
	- <parameter type-id='857bb57e'/>
	+ <function-decl name='zfs_release' mangled-name='zfs_release' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_release'>
	+ <parameter type-id='9200a744' name='zhp'/>
	+ <parameter type-id='80f4b756' name='snapname'/>
	+ <parameter type-id='80f4b756' name='tag'/>
	+ <parameter type-id='c19b74c3' name='recursive'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zprop_expand_list' mangled-name='zprop_expand_list' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zprop_expand_list'>
	- <parameter type-id='b0382bb3'/>
	- <parameter type-id='e4378506'/>
	- <parameter type-id='2e45de5d'/>
	+ <function-decl name='zfs_get_fsacl' mangled-name='zfs_get_fsacl' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_get_fsacl'>
	+ <parameter type-id='9200a744' name='zhp'/>
	+ <parameter type-id='857bb57e' name='nvl'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='nvlist_remove' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='5ce45b60'/>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='8d0687d2'/>
	+ <function-decl name='zfs_set_fsacl' mangled-name='zfs_set_fsacl' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_set_fsacl'>
	+ <parameter type-id='9200a744' name='zhp'/>
	+ <parameter type-id='c19b74c3' name='un'/>
	+ <parameter type-id='5ce45b60' name='nvl'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='lzc_hold' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='5ce45b60'/>
	- <parameter type-id='95e97e5e'/>
	- <parameter type-id='857bb57e'/>
	+ <function-decl name='zfs_get_holds' mangled-name='zfs_get_holds' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_get_holds'>
	+ <parameter type-id='9200a744' name='zhp'/>
	+ <parameter type-id='857bb57e' name='nvl'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='lzc_release' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='5ce45b60'/>
	- <parameter type-id='857bb57e'/>
	+ <function-decl name='zvol_volsize_to_reservation' mangled-name='zvol_volsize_to_reservation' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zvol_volsize_to_reservation'>
	+ <parameter type-id='4c81de99' name='zph'/>
	+ <parameter type-id='9c313c2d' name='volsize'/>
	+ <parameter type-id='5ce45b60' name='props'/>
	+ <return type-id='9c313c2d'/>
	+ </function-decl>
	+ <function-decl name='zfs_wait_status' mangled-name='zfs_wait_status' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_wait_status'>
	+ <parameter type-id='9200a744' name='zhp'/>
	+ <parameter type-id='3024501a' name='activity'/>
	+ <parameter type-id='37e3bd22' name='missing'/>
	+ <parameter type-id='37e3bd22' name='waited'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='nvlist_unpack' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='26a90f95'/>
	- <parameter type-id='b59d7dce'/>
	- <parameter type-id='857bb57e'/>
	- <parameter type-id='95e97e5e'/>
	+ <function-decl name='getgrnam' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='80f4b756'/>
	+ <return type-id='566b3f52'/>
	+ </function-decl>
	+ <function-decl name='hasmntopt' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='48bea5ec'/>
	+ <parameter type-id='80f4b756'/>
	+ <return type-id='26a90f95'/>
	+ </function-decl>
	+ <function-decl name='pthread_mutex_init' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='18c91f9e'/>
	+ <parameter type-id='c2afbd7e'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='nvlist_size' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='5ce45b60'/>
	- <parameter type-id='78c01427'/>
	- <parameter type-id='95e97e5e'/>
	+ <function-decl name='pthread_mutex_destroy' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='18c91f9e'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='nvlist_pack' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='5ce45b60'/>
	- <parameter type-id='9b23c9ad'/>
	- <parameter type-id='78c01427'/>
	- <parameter type-id='95e97e5e'/>
	- <parameter type-id='95e97e5e'/>
	+ <function-decl name='pthread_mutex_lock' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='18c91f9e'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='nvlist_lookup_nvlist_array' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='5ce45b60'/>
	+ <function-decl name='pthread_mutex_unlock' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='18c91f9e'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='getpwnam' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='80f4b756'/>
	- <parameter type-id='75be733c'/>
	- <parameter type-id='4dd26a40'/>
	+ <return type-id='a195f4a3'/>
	+ </function-decl>
	+ <function-decl name='fprintf' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='e75a27e9'/>
	+ <parameter type-id='9d26089a'/>
	+ <parameter is-variadic='yes'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='asprintf' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='8c85230f'/>
	+ <parameter type-id='9d26089a'/>
	+ <parameter is-variadic='yes'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='strtol' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='9b23c9ad'/>
	+ <parameter type-id='9d26089a'/>
	+ <parameter type-id='8c85230f'/>
	<parameter type-id='95e97e5e'/>
	<return type-id='bd54fe1a'/>
	</function-decl>
	- <function-decl name='fnvlist_add_uint64' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='5ce45b60'/>
	+ <function-decl name='strtoul' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='9d26089a'/>
	+ <parameter type-id='8c85230f'/>
	+ <parameter type-id='95e97e5e'/>
	+ <return type-id='7359adad'/>
	+ </function-decl>
	+ <function-decl name='abort' visibility='default' binding='global' size-in-bits='64'>
	+ <return type-id='48b5725f'/>
	+ </function-decl>
	+ <function-decl name='strncpy' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='26a90f95'/>
	<parameter type-id='80f4b756'/>
	- <parameter type-id='9c313c2d'/>
	- <return type-id='48b5725f'/>
	+ <parameter type-id='b59d7dce'/>
	+ <return type-id='26a90f95'/>
	</function-decl>
	- <function-decl name='nvlist_remove_all' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='5ce45b60'/>
	+ <function-decl name='strdup' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='80f4b756'/>
	- <return type-id='95e97e5e'/>
	+ <return type-id='26a90f95'/>
	</function-decl>
	- <function-decl name='zfs_setprop_error' mangled-name='zfs_setprop_error' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_setprop_error'>
	- <parameter type-id='b0382bb3'/>
	- <parameter type-id='58603c44'/>
	+ <function-decl name='strrchr' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='80f4b756'/>
	<parameter type-id='95e97e5e'/>
	- <parameter type-id='26a90f95'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	- <function-decl name='fnvpair_value_uint64' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='3fa542f0'/>
	- <return type-id='9c313c2d'/>
	- </function-decl>
	- <function-decl name='zfs_iter_snapshots' mangled-name='zfs_iter_snapshots' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_iter_snapshots'>
	- <parameter type-id='9200a744'/>
	- <parameter type-id='c19b74c3'/>
	- <parameter type-id='d8e49ab9'/>
	- <parameter type-id='eaa32e2f'/>
	- <parameter type-id='9c313c2d'/>
	- <parameter type-id='9c313c2d'/>
	- <return type-id='95e97e5e'/>
	+ <return type-id='26a90f95'/>
	</function-decl>
	- <function-decl name='lzc_rollback_to' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='strcspn' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='80f4b756'/>
	<parameter type-id='80f4b756'/>
	- <return type-id='95e97e5e'/>
	+ <return type-id='b59d7dce'/>
	</function-decl>
	- <function-decl name='lzc_clone' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='strstr' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='80f4b756'/>
	<parameter type-id='80f4b756'/>
	- <parameter type-id='5ce45b60'/>
	- <return type-id='95e97e5e'/>
	+ <return type-id='26a90f95'/>
	</function-decl>
	- <function-decl name='lzc_wait_fs' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='3024501a'/>
	- <parameter type-id='37e3bd22'/>
	+ <function-decl name='strsep' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='8c85230f'/>
	+ <parameter type-id='9d26089a'/>
	+ <return type-id='26a90f95'/>
	+ </function-decl>
	+ <function-decl name='ioctl' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='95e97e5e'/>
	+ <parameter type-id='7359adad'/>
	+ <parameter is-variadic='yes'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	+ <function-decl name='strftime' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='266fe297'/>
	+ <parameter type-id='b59d7dce'/>
	+ <parameter type-id='9d26089a'/>
	+ <parameter type-id='f8c6051d'/>
	+ <return type-id='b59d7dce'/>
	+ </function-decl>
	+ <function-decl name='localtime_r' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='d6e2847c'/>
	+ <parameter type-id='f099ad08'/>
	+ <return type-id='d915a820'/>
	+ </function-decl>
	<function-type size-in-bits='64' id='7e291ce6'>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='354978ed'/>
	<parameter type-id='9c313c2d'/>
	<return type-id='95e97e5e'/>
	</function-type>
	</abi-instr>
	- <abi-instr version='1.0' address-size='64' path='libzfs_diff.c' language='LANG_C89'>
	+ <abi-instr address-size='64' path='libzfs_diff.c' language='LANG_C99'>
	<array-type-def dimensions='1' type-id='a84c031d' size-in-bits='448' id='6093ff7c'>
	- <subrange length='56' type-id='4c87fef4' id='f8137894'/>
	+ <subrange length='56' type-id='7359adad' id='f8137894'/>
	</array-type-def>
	- <typedef-decl name='differ_info_t' type-id='d41965ee' id='e8525f0e'/>
	<class-decl name='differ_info' size-in-bits='9024' is-struct='yes' visibility='default' id='d41965ee'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='zhp' type-id='9200a744' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='fromsnap' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='frommnt' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	<var-decl name='tosnap' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='256'>
	<var-decl name='tomnt' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='320'>
	<var-decl name='ds' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='384'>
	<var-decl name='dsmnt' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='448'>
	<var-decl name='tmpsnap' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='512'>
	<var-decl name='errbuf' type-id='b54ce520' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='8704'>
	<var-decl name='isclone' type-id='c19b74c3' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='8736'>
	<var-decl name='scripted' type-id='c19b74c3' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='8768'>
	<var-decl name='classify' type-id='c19b74c3' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='8800'>
	<var-decl name='timestamped' type-id='c19b74c3' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='8832'>
	<var-decl name='shares' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='8896'>
	<var-decl name='zerr' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='8928'>
	<var-decl name='cleanupfd' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='8960'>
	<var-decl name='outputfd' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='8992'>
	<var-decl name='datafd' type-id='95e97e5e' visibility='default'/>
	</data-member>
	</class-decl>
	+ <typedef-decl name='differ_info_t' type-id='d41965ee' id='e8525f0e'/>
	<typedef-decl name='pthread_t' type-id='7359adad' id='4051f5e7'/>
	- <typedef-decl name='pthread_attr_t' type-id='b63afacd' id='7d8569fd'/>
	<union-decl name='pthread_attr_t' size-in-bits='448' visibility='default' id='b63afacd'>
	- <data-member access='private'>
	+ <data-member access='public'>
	<var-decl name='__size' type-id='6093ff7c' visibility='default'/>
	</data-member>
	- <data-member access='private'>
	+ <data-member access='public'>
	<var-decl name='__align' type-id='bd54fe1a' visibility='default'/>
	</data-member>
	</union-decl>
	+ <typedef-decl name='pthread_attr_t' type-id='b63afacd' id='7d8569fd'/>
	<qualified-type-def type-id='7d8569fd' const='yes' id='e06dee2d'/>
	<pointer-type-def type-id='e06dee2d' size-in-bits='64' id='540db505'/>
	+ <qualified-type-def type-id='540db505' restrict='yes' id='e1815e87'/>
	<pointer-type-def type-id='e8525f0e' size-in-bits='64' id='ee78f675'/>
	<pointer-type-def type-id='4051f5e7' size-in-bits='64' id='e01b5462'/>
	+ <qualified-type-def type-id='e01b5462' restrict='yes' id='cc338b26'/>
	<pointer-type-def type-id='cd5d79f4' size-in-bits='64' id='5ad9edb6'/>
	- <function-decl name='zfs_show_diffs' mangled-name='zfs_show_diffs' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_show_diffs'>
	- <parameter type-id='9200a744' name='zhp'/>
	- <parameter type-id='95e97e5e' name='outfd'/>
	- <parameter type-id='80f4b756' name='fromsnap'/>
	- <parameter type-id='80f4b756' name='tosnap'/>
	- <parameter type-id='95e97e5e' name='flags'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='zfs_asprintf' mangled-name='zfs_asprintf' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_asprintf'>
	- <parameter type-id='b0382bb3'/>
	- <parameter type-id='80f4b756'/>
	- <parameter is-variadic='yes'/>
	- <return type-id='26a90f95'/>
	- </function-decl>
	<function-decl name='is_mounted' mangled-name='is_mounted' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='is_mounted'>
	<parameter type-id='b0382bb3'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='9b23c9ad'/>
	<return type-id='c19b74c3'/>
	</function-decl>
	- <function-decl name='fdopen' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='95e97e5e'/>
	+ <function-decl name='zfs_asprintf' mangled-name='zfs_asprintf' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_asprintf'>
	+ <parameter type-id='b0382bb3'/>
	<parameter type-id='80f4b756'/>
	- <return type-id='822cd80b'/>
	+ <parameter is-variadic='yes'/>
	+ <return type-id='26a90f95'/>
	</function-decl>
	<function-decl name='find_shares_object' mangled-name='find_shares_object' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='find_shares_object'>
	<parameter type-id='ee78f675'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='pipe2' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='7292109c'/>
	- <parameter type-id='95e97e5e'/>
	+ <function-decl name='zfs_show_diffs' mangled-name='zfs_show_diffs' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_show_diffs'>
	+ <parameter type-id='9200a744' name='zhp'/>
	+ <parameter type-id='95e97e5e' name='outfd'/>
	+ <parameter type-id='80f4b756' name='fromsnap'/>
	+ <parameter type-id='80f4b756' name='tosnap'/>
	+ <parameter type-id='95e97e5e' name='flags'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='pthread_create' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='e01b5462'/>
	- <parameter type-id='540db505'/>
	+ <parameter type-id='cc338b26'/>
	+ <parameter type-id='e1815e87'/>
	<parameter type-id='5ad9edb6'/>
	- <parameter type-id='eaa32e2f'/>
	+ <parameter type-id='1b7446cd'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='pthread_cancel' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='pthread_join' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='4051f5e7'/>
	+ <parameter type-id='63e171df'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='pthread_join' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='pthread_cancel' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='4051f5e7'/>
	- <parameter type-id='63e171df'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='fdopen' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='95e97e5e'/>
	+ <parameter type-id='80f4b756'/>
	+ <return type-id='822cd80b'/>
	+ </function-decl>
	+ <function-decl name='pipe2' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='7292109c'/>
	+ <parameter type-id='95e97e5e'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-type size-in-bits='64' id='cd5d79f4'>
	<parameter type-id='eaa32e2f'/>
	<return type-id='eaa32e2f'/>
	</function-type>
	</abi-instr>
	- <abi-instr version='1.0' address-size='64' path='libzfs_import.c' language='LANG_C89'>
	+ <abi-instr address-size='64' path='libzfs_import.c' language='LANG_C99'>
	<array-type-def dimensions='1' type-id='03085adc' size-in-bits='192' id='083f8d58'>
	- <subrange length='3' type-id='4c87fef4' id='56f209d2'/>
	+ <subrange length='3' type-id='7359adad' id='56f209d2'/>
	</array-type-def>
	- <typedef-decl name='pool_state_t' type-id='4871ac24' id='084a08a3'/>
	+ <typedef-decl name='refresh_config_func_t' type-id='29f040d2' id='b7c58eaa'/>
	+ <typedef-decl name='pool_active_func_t' type-id='baa42fef' id='de5d1d8f'/>
	+ <class-decl name='pool_config_ops' size-in-bits='128' is-struct='yes' visibility='default' id='8b092c69'>
	+ <data-member access='public' layout-offset-in-bits='0'>
	+ <var-decl name='pco_refresh_config' type-id='e7c00489' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='64'>
	+ <var-decl name='pco_pool_active' type-id='9eadf5e0' visibility='default'/>
	+ </data-member>
	+ </class-decl>
	+ <typedef-decl name='pool_config_ops_t' type-id='1a21babe' id='b1e62775'/>
	<enum-decl name='pool_state' id='4871ac24'>
	<underlying-type type-id='9cac1fee'/>
	<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_config_ops_t' type-id='1a21babe' id='b1e62775'/>
	- <class-decl name='pool_config_ops' size-in-bits='128' is-struct='yes' visibility='default' id='8b092c69'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='pco_refresh_config' type-id='e7c00489' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='pco_pool_active' type-id='9eadf5e0' visibility='default'/>
	- </data-member>
	- </class-decl>
	- <typedef-decl name='refresh_config_func_t' type-id='29f040d2' id='b7c58eaa'/>
	- <typedef-decl name='pool_active_func_t' type-id='baa42fef' id='de5d1d8f'/>
	+ <typedef-decl name='pool_state_t' type-id='4871ac24' id='084a08a3'/>
	<class-decl name='stat64' size-in-bits='1152' is-struct='yes' visibility='default' id='0bbec9cd'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='st_dev' type-id='35ed8932' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='st_ino' type-id='71288a47' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='st_nlink' type-id='80f0b9df' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	<var-decl name='st_mode' type-id='e1c52942' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='224'>
	<var-decl name='st_uid' type-id='cc5fcceb' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='256'>
	<var-decl name='st_gid' type-id='d94ec6d9' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='288'>
	<var-decl name='__pad0' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='320'>
	<var-decl name='st_rdev' type-id='35ed8932' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='384'>
	<var-decl name='st_size' type-id='79989e9c' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='448'>
	<var-decl name='st_blksize' type-id='d3f10a7f' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='512'>
	<var-decl name='st_blocks' type-id='4e711bf1' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='576'>
	<var-decl name='st_atim' type-id='a9c79a1f' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='704'>
	<var-decl name='st_mtim' type-id='a9c79a1f' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='832'>
	<var-decl name='st_ctim' type-id='a9c79a1f' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='960'>
	- <var-decl name='__unused' type-id='083f8d58' visibility='default'/>
	+ <var-decl name='__glibc_reserved' type-id='083f8d58' visibility='default'/>
	</data-member>
	</class-decl>
	<typedef-decl name='__dev_t' type-id='7359adad' id='35ed8932'/>
	<typedef-decl name='__ino64_t' type-id='7359adad' id='71288a47'/>
	- <typedef-decl name='__nlink_t' type-id='7359adad' id='80f0b9df'/>
	<typedef-decl name='__mode_t' type-id='f0981eeb' id='e1c52942'/>
	+ <typedef-decl name='__nlink_t' type-id='7359adad' id='80f0b9df'/>
	<typedef-decl name='__blksize_t' type-id='bd54fe1a' id='d3f10a7f'/>
	<typedef-decl name='__blkcnt64_t' type-id='bd54fe1a' id='4e711bf1'/>
	+ <typedef-decl name='__syscall_slong_t' type-id='bd54fe1a' id='03085adc'/>
	<class-decl name='timespec' size-in-bits='128' is-struct='yes' visibility='default' id='a9c79a1f'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='tv_sec' type-id='65eda9c0' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='tv_nsec' type-id='03085adc' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='__syscall_slong_t' type-id='bd54fe1a' id='03085adc'/>
	<qualified-type-def type-id='8b092c69' const='yes' id='1a21babe'/>
	<pointer-type-def type-id='de5d1d8f' size-in-bits='64' id='9eadf5e0'/>
	<pointer-type-def type-id='084a08a3' size-in-bits='64' id='b9ea57b8'/>
	<pointer-type-def type-id='b7c58eaa' size-in-bits='64' id='e7c00489'/>
	<pointer-type-def type-id='0bbec9cd' size-in-bits='64' id='62f7a03d'/>
	+ <function-decl name='zcmd_write_conf_nvlist' mangled-name='zcmd_write_conf_nvlist' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zcmd_write_conf_nvlist'>
	+ <parameter type-id='b0382bb3'/>
	+ <parameter type-id='e4ec4540'/>
	+ <parameter type-id='5ce45b60'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <var-decl name='libzfs_config_ops' type-id='b1e62775' mangled-name='libzfs_config_ops' visibility='default' elf-symbol-id='libzfs_config_ops'/>
	+ <function-decl name='zpool_read_label' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='95e97e5e'/>
	+ <parameter type-id='857bb57e'/>
	+ <parameter type-id='7292109c'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	<function-decl name='zpool_clear_label' mangled-name='zpool_clear_label' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_clear_label'>
	<parameter type-id='95e97e5e' name='fd'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='zpool_in_use' mangled-name='zpool_in_use' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_in_use'>
	<parameter type-id='b0382bb3' name='hdl'/>
	<parameter type-id='95e97e5e' name='fd'/>
	<parameter type-id='b9ea57b8' name='state'/>
	<parameter type-id='9b23c9ad' name='namestr'/>
	<parameter type-id='37e3bd22' name='inuse'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <var-decl name='libzfs_config_ops' type-id='b1e62775' mangled-name='libzfs_config_ops' visibility='default' elf-symbol-id='libzfs_config_ops'/>
	- <function-decl name='zcmd_write_conf_nvlist' mangled-name='zcmd_write_conf_nvlist' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zcmd_write_conf_nvlist'>
	- <parameter type-id='b0382bb3'/>
	- <parameter type-id='e4ec4540'/>
	- <parameter type-id='5ce45b60'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='__fxstat64' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='memset' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='eaa32e2f'/>
	<parameter type-id='95e97e5e'/>
	+ <parameter type-id='b59d7dce'/>
	+ <return type-id='eaa32e2f'/>
	+ </function-decl>
	+ <function-decl name='fstat64' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='95e97e5e'/>
	<parameter type-id='62f7a03d'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='pread64' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='95e97e5e'/>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='b59d7dce'/>
	<parameter type-id='724e4de6'/>
	<return type-id='79a0948f'/>
	</function-decl>
	<function-decl name='pwrite64' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='95e97e5e'/>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='b59d7dce'/>
	<parameter type-id='724e4de6'/>
	<return type-id='79a0948f'/>
	</function-decl>
	- <function-decl name='zpool_read_label' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='95e97e5e'/>
	- <parameter type-id='857bb57e'/>
	- <parameter type-id='7292109c'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	<function-type size-in-bits='64' id='baa42fef'>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='9c313c2d'/>
	<parameter type-id='37e3bd22'/>
	<return type-id='95e97e5e'/>
	</function-type>
	<function-type size-in-bits='64' id='29f040d2'>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='5ce45b60'/>
	<return type-id='5ce45b60'/>
	</function-type>
	</abi-instr>
	- <abi-instr version='1.0' address-size='64' path='libzfs_iter.c' language='LANG_C89'>
	+ <abi-instr address-size='64' path='libzfs_iter.c' language='LANG_C99'>
	<pointer-type-def type-id='b351119f' size-in-bits='64' id='716943c7'/>
	+ <function-decl name='avl_first' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='a3681dea'/>
	+ <return type-id='eaa32e2f'/>
	+ </function-decl>
	+ <function-decl name='avl_walk' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='716943c7'/>
	+ <parameter type-id='eaa32e2f'/>
	+ <parameter type-id='95e97e5e'/>
	+ <return type-id='eaa32e2f'/>
	+ </function-decl>
	+ <function-decl name='fnvpair_value_nvlist' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='3fa542f0'/>
	+ <return type-id='5ce45b60'/>
	+ </function-decl>
	<function-decl name='zfs_iter_snapshots_sorted' mangled-name='zfs_iter_snapshots_sorted' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_iter_snapshots_sorted'>
	<parameter type-id='9200a744' name='zhp'/>
	<parameter type-id='d8e49ab9' name='callback'/>
	<parameter type-id='eaa32e2f' name='data'/>
	<parameter type-id='9c313c2d' name='min_txg'/>
	<parameter type-id='9c313c2d' name='max_txg'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='zfs_iter_snapspec' mangled-name='zfs_iter_snapspec' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_iter_snapspec'>
	<parameter type-id='9200a744' name='fs_zhp'/>
	<parameter type-id='80f4b756' name='spec_orig'/>
	<parameter type-id='d8e49ab9' name='func'/>
	<parameter type-id='eaa32e2f' name='arg'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='fnvpair_value_nvlist' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='3fa542f0'/>
	- <return type-id='5ce45b60'/>
	- </function-decl>
	- <function-decl name='avl_first' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='a3681dea'/>
	- <return type-id='eaa32e2f'/>
	- </function-decl>
	- <function-decl name='avl_walk' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='716943c7'/>
	- <parameter type-id='eaa32e2f'/>
	- <parameter type-id='95e97e5e'/>
	- <return type-id='eaa32e2f'/>
	- </function-decl>
	</abi-instr>
	- <abi-instr version='1.0' address-size='64' path='libzfs_mount.c' language='LANG_C89'>
	+ <abi-instr address-size='64' path='libzfs_mount.c' language='LANG_C99'>
	<array-type-def dimensions='1' type-id='6028cbfe' size-in-bits='256' id='b39b9aa7'>
	- <subrange length='4' type-id='4c87fef4' id='16fe7105'/>
	+ <subrange length='4' type-id='7359adad' id='16fe7105'/>
	</array-type-def>
	<class-decl name='__dirstream' is-struct='yes' visibility='default' is-declaration-only='yes' id='20cd73f2'/>
	<class-decl name='tpool' is-struct='yes' visibility='default' is-declaration-only='yes' id='88d1b7f9'/>
	<array-type-def dimensions='1' type-id='95e97e5e' size-in-bits='64' id='e4266c7e'>
	- <subrange length='2' type-id='4c87fef4' id='52efc4ef'/>
	+ <subrange length='2' type-id='7359adad' id='52efc4ef'/>
	</array-type-def>
	<array-type-def dimensions='1' type-id='f1bd64e2' size-in-bits='384' id='b2c36c9f'>
	- <subrange length='2' type-id='4c87fef4' id='52efc4ef'/>
	+ <subrange length='2' type-id='7359adad' id='52efc4ef'/>
	</array-type-def>
	<array-type-def dimensions='1' type-id='a7913f77' size-in-bits='64' alignment-in-bits='32' id='79c9b3ac'>
	- <subrange length='2' type-id='4c87fef4' id='52efc4ef'/>
	+ <subrange length='2' type-id='7359adad' id='52efc4ef'/>
	</array-type-def>
	<array-type-def dimensions='1' type-id='a7913f77' size-in-bits='96' alignment-in-bits='32' id='7dc77b61'>
	- <subrange length='3' type-id='4c87fef4' id='56f209d2'/>
	+ <subrange length='3' type-id='7359adad' id='56f209d2'/>
	</array-type-def>
	- <typedef-decl name='zfs_share_type_t' type-id='08f5ca1d' id='7eb57c2d'/>
	- <enum-decl name='__anonymous_enum__' is-anonymous='yes' id='08f5ca1d'>
	- <underlying-type type-id='9cac1fee'/>
	- <enumerator name='SHARED_NOT_SHARED' value='0'/>
	- <enumerator name='SHARED_NFS' value='2'/>
	- <enumerator name='SHARED_SMB' value='4'/>
	- </enum-decl>
	- <typedef-decl name='get_all_cb_t' type-id='803dac95' id='9b293607'/>
	<class-decl name='get_all_cb' size-in-bits='192' is-struct='yes' visibility='default' id='803dac95'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='cb_handles' type-id='4507922a' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='cb_alloc' type-id='b59d7dce' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='cb_used' type-id='b59d7dce' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='proto_table_t' type-id='9faf92fc' id='f1bd64e2'/>
	- <class-decl name='__anonymous_struct__' size-in-bits='192' is-struct='yes' is-anonymous='yes' naming-typedef-id='f1bd64e2' visibility='default' id='9faf92fc'>
	+ <typedef-decl name='get_all_cb_t' type-id='803dac95' id='9b293607'/>
	+ <enum-decl name='zfs_share_type_t' naming-typedef-id='7eb57c2d' id='5bc85791'>
	+ <underlying-type type-id='9cac1fee'/>
	+ <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='5bc85791' id='7eb57c2d'/>
	+ <class-decl name='proto_table_t' size-in-bits='192' is-struct='yes' naming-typedef-id='f1bd64e2' visibility='default' id='f4c8e1ed'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='p_prop' type-id='58603c44' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='p_name' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='p_share_err' type-id='95e97e5e' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='160'>
	- <var-decl name='p_unshare_err' type-id='95e97e5e' visibility='default'/>
	- </data-member>
	- </class-decl>
	- <typedef-decl name='tpool_t' type-id='88d1b7f9' id='b1bbf10d'/>
	- <class-decl name='stat' size-in-bits='1152' is-struct='yes' visibility='default' id='aafc373f'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='st_dev' type-id='35ed8932' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='st_ino' type-id='e43e523d' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='st_nlink' type-id='80f0b9df' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='192'>
	- <var-decl name='st_mode' type-id='e1c52942' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='224'>
	- <var-decl name='st_uid' type-id='cc5fcceb' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='256'>
	- <var-decl name='st_gid' type-id='d94ec6d9' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='288'>
	- <var-decl name='__pad0' type-id='95e97e5e' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='320'>
	- <var-decl name='st_rdev' type-id='35ed8932' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='384'>
	- <var-decl name='st_size' type-id='79989e9c' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='448'>
	- <var-decl name='st_blksize' type-id='d3f10a7f' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='512'>
	- <var-decl name='st_blocks' type-id='dbc43803' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='576'>
	- <var-decl name='st_atim' type-id='a9c79a1f' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='704'>
	- <var-decl name='st_mtim' type-id='a9c79a1f' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='832'>
	- <var-decl name='st_ctim' type-id='a9c79a1f' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='960'>
	- <var-decl name='__unused' type-id='083f8d58' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='160'>
	+ <var-decl name='p_unshare_err' type-id='95e97e5e' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='__ino_t' type-id='7359adad' id='e43e523d'/>
	- <typedef-decl name='__blkcnt_t' type-id='bd54fe1a' id='dbc43803'/>
	- <typedef-decl name='DIR' type-id='20cd73f2' id='54a5d683'/>
	+ <typedef-decl name='proto_table_t' type-id='f4c8e1ed' id='f1bd64e2'/>
	+ <typedef-decl name='tpool_t' type-id='88d1b7f9' id='b1bbf10d'/>
	<class-decl name='dirent64' size-in-bits='2240' is-struct='yes' visibility='default' id='5725d813'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='d_ino' type-id='71288a47' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='d_off' type-id='724e4de6' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='d_reclen' type-id='8efea9e5' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='144'>
	<var-decl name='d_type' type-id='002ac4a6' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='152'>
	<var-decl name='d_name' type-id='d1617432' visibility='default'/>
	</data-member>
	</class-decl>
	<class-decl name='statfs64' size-in-bits='960' is-struct='yes' visibility='default' id='a2a6be1a'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='f_type' type-id='6028cbfe' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='f_bsize' type-id='6028cbfe' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='f_blocks' type-id='95fe1a02' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	<var-decl name='f_bfree' type-id='95fe1a02' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='256'>
	<var-decl name='f_bavail' type-id='95fe1a02' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='320'>
	<var-decl name='f_files' type-id='0c3a4dde' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='384'>
	<var-decl name='f_ffree' type-id='0c3a4dde' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='448'>
	<var-decl name='f_fsid' type-id='0f35d263' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='512'>
	<var-decl name='f_namelen' type-id='6028cbfe' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='576'>
	<var-decl name='f_frsize' type-id='6028cbfe' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='640'>
	<var-decl name='f_flags' type-id='6028cbfe' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='704'>
	<var-decl name='f_spare' type-id='b39b9aa7' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='__fsword_t' type-id='bd54fe1a' id='6028cbfe'/>
	- <typedef-decl name='__fsblkcnt64_t' type-id='7359adad' id='95fe1a02'/>
	- <typedef-decl name='__fsfilcnt64_t' type-id='7359adad' id='0c3a4dde'/>
	- <typedef-decl name='__fsid_t' type-id='dfecf3ee' id='0f35d263'/>
	- <class-decl name='__anonymous_struct__1' size-in-bits='64' is-struct='yes' is-anonymous='yes' naming-typedef-id='0f35d263' visibility='default' id='dfecf3ee'>
	+ <class-decl name='stat' size-in-bits='1152' is-struct='yes' visibility='default' id='aafc373f'>
	+ <data-member access='public' layout-offset-in-bits='0'>
	+ <var-decl name='st_dev' type-id='35ed8932' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='64'>
	+ <var-decl name='st_ino' type-id='e43e523d' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='128'>
	+ <var-decl name='st_nlink' type-id='80f0b9df' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='192'>
	+ <var-decl name='st_mode' type-id='e1c52942' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='224'>
	+ <var-decl name='st_uid' type-id='cc5fcceb' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='256'>
	+ <var-decl name='st_gid' type-id='d94ec6d9' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='288'>
	+ <var-decl name='__pad0' type-id='95e97e5e' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='320'>
	+ <var-decl name='st_rdev' type-id='35ed8932' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='384'>
	+ <var-decl name='st_size' type-id='79989e9c' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='448'>
	+ <var-decl name='st_blksize' type-id='d3f10a7f' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='512'>
	+ <var-decl name='st_blocks' type-id='dbc43803' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='576'>
	+ <var-decl name='st_atim' type-id='a9c79a1f' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='704'>
	+ <var-decl name='st_mtim' type-id='a9c79a1f' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='832'>
	+ <var-decl name='st_ctim' type-id='a9c79a1f' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='960'>
	+ <var-decl name='__glibc_reserved' type-id='083f8d58' visibility='default'/>
	+ </data-member>
	+ </class-decl>
	+ <typedef-decl name='__ino_t' type-id='7359adad' id='e43e523d'/>
	+ <class-decl name='__fsid_t' size-in-bits='64' is-struct='yes' naming-typedef-id='0f35d263' visibility='default' id='ea35c84a'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='__val' type-id='e4266c7e' visibility='default'/>
	</data-member>
	</class-decl>
	+ <typedef-decl name='__fsid_t' type-id='ea35c84a' id='0f35d263'/>
	+ <typedef-decl name='__blkcnt_t' type-id='bd54fe1a' id='dbc43803'/>
	+ <typedef-decl name='__fsblkcnt64_t' type-id='7359adad' id='95fe1a02'/>
	+ <typedef-decl name='__fsfilcnt64_t' type-id='7359adad' id='0c3a4dde'/>
	+ <typedef-decl name='__fsword_t' type-id='bd54fe1a' id='6028cbfe'/>
	+ <typedef-decl name='DIR' type-id='20cd73f2' id='54a5d683'/>
	<typedef-decl name='mode_t' type-id='e1c52942' id='d50d396c'/>
	<typedef-decl name='__compar_fn_t' type-id='585e1de9' id='aba7edd8'/>
	<pointer-type-def type-id='54a5d683' size-in-bits='64' id='f09217ba'/>
	<pointer-type-def type-id='5725d813' size-in-bits='64' id='07b96073'/>
	<pointer-type-def type-id='9b293607' size-in-bits='64' id='77bf1784'/>
	<pointer-type-def type-id='7d8569fd' size-in-bits='64' id='7347a39e'/>
	<pointer-type-def type-id='aafc373f' size-in-bits='64' id='4330df87'/>
	+ <qualified-type-def type-id='4330df87' restrict='yes' id='73665405'/>
	<pointer-type-def type-id='a2a6be1a' size-in-bits='64' id='7fd094c8'/>
	<pointer-type-def type-id='b1bbf10d' size-in-bits='64' id='9cf59a50'/>
	<pointer-type-def type-id='c5c76c9c' size-in-bits='64' id='b7f9d8e6'/>
	<pointer-type-def type-id='9200a744' size-in-bits='64' id='4507922a'/>
	+ <class-decl name='__dirstream' is-struct='yes' visibility='default' is-declaration-only='yes' id='20cd73f2'/>
	+ <class-decl name='tpool' is-struct='yes' visibility='default' is-declaration-only='yes' id='88d1b7f9'/>
	+ <function-decl name='zfs_realloc' mangled-name='zfs_realloc' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_realloc'>
	+ <parameter type-id='b0382bb3'/>
	+ <parameter type-id='eaa32e2f'/>
	+ <parameter type-id='b59d7dce'/>
	+ <parameter type-id='b59d7dce'/>
	+ <return type-id='eaa32e2f'/>
	+ </function-decl>
	+ <var-decl name='proto_table' type-id='b2c36c9f' mangled-name='proto_table' visibility='default' elf-symbol-id='proto_table'/>
	+ <function-decl name='do_mount' mangled-name='do_mount' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='do_mount'>
	+ <parameter type-id='9200a744'/>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='26a90f95'/>
	+ <parameter type-id='95e97e5e'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='do_unmount' mangled-name='do_unmount' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='do_unmount'>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='95e97e5e'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='tpool_create' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='3502e3ff'/>
	+ <parameter type-id='3502e3ff'/>
	+ <parameter type-id='3502e3ff'/>
	+ <parameter type-id='7347a39e'/>
	+ <return type-id='9cf59a50'/>
	+ </function-decl>
	+ <function-decl name='tpool_dispatch' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='9cf59a50'/>
	+ <parameter type-id='b7f9d8e6'/>
	+ <parameter type-id='eaa32e2f'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='tpool_destroy' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='9cf59a50'/>
	+ <return type-id='48b5725f'/>
	+ </function-decl>
	+ <function-decl name='tpool_wait' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='9cf59a50'/>
	+ <return type-id='48b5725f'/>
	+ </function-decl>
	+ <function-decl name='mkdirp' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='d50d396c'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='sa_errorstr' mangled-name='sa_errorstr' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='sa_errorstr'>
	+ <parameter type-id='95e97e5e'/>
	+ <return type-id='26a90f95'/>
	+ </function-decl>
	+ <function-decl name='sa_enable_share' mangled-name='sa_enable_share' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='sa_enable_share'>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='26a90f95'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='sa_disable_share' mangled-name='sa_disable_share' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='sa_disable_share'>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='26a90f95'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='sa_is_shared' mangled-name='sa_is_shared' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='sa_is_shared'>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='26a90f95'/>
	+ <return type-id='c19b74c3'/>
	+ </function-decl>
	+ <function-decl name='sa_commit_shares' mangled-name='sa_commit_shares' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='sa_commit_shares'>
	+ <parameter type-id='80f4b756'/>
	+ <return type-id='48b5725f'/>
	+ </function-decl>
	+ <function-decl name='sa_validate_shareopts' mangled-name='sa_validate_shareopts' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='sa_validate_shareopts'>
	+ <parameter type-id='26a90f95'/>
	+ <parameter type-id='26a90f95'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <var-decl name='nfs_only' type-id='79c9b3ac' mangled-name='nfs_only' visibility='default' elf-symbol-id='nfs_only'/>
	+ <var-decl name='smb_only' type-id='79c9b3ac' mangled-name='smb_only' visibility='default' elf-symbol-id='smb_only'/>
	+ <var-decl name='share_all_proto' type-id='7dc77b61' mangled-name='share_all_proto' visibility='default' elf-symbol-id='share_all_proto'/>
	<function-decl name='zfs_is_mountable' mangled-name='zfs_is_mountable' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_is_mountable'>
	<parameter type-id='9200a744' name='zhp'/>
	<parameter type-id='26a90f95' name='buf'/>
	<parameter type-id='b59d7dce' name='buflen'/>
	<parameter type-id='debc6aa3' name='source'/>
	<parameter type-id='95e97e5e' name='flags'/>
	<return type-id='c19b74c3'/>
	</function-decl>
	<function-decl name='zfs_mount_at' mangled-name='zfs_mount_at' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_mount_at'>
	<parameter type-id='9200a744' name='zhp'/>
	<parameter type-id='80f4b756' name='options'/>
	<parameter type-id='95e97e5e' name='flags'/>
	<parameter type-id='80f4b756' name='mountpoint'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='zfs_unmountall' mangled-name='zfs_unmountall' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_unmountall'>
	<parameter type-id='9200a744' name='zhp'/>
	<parameter type-id='95e97e5e' name='flags'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='unshare_one' mangled-name='unshare_one' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='unshare_one'>
	<parameter type-id='b0382bb3' name='hdl'/>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='80f4b756' name='mountpoint'/>
	<parameter type-id='a7913f77' name='proto'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='is_shared' mangled-name='is_shared' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='is_shared'>
	<parameter type-id='80f4b756' name='mountpoint'/>
	<parameter type-id='a7913f77' name='proto'/>
	<return type-id='7eb57c2d'/>
	</function-decl>
	<function-decl name='zfs_share_proto' mangled-name='zfs_share_proto' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_share_proto'>
	<parameter type-id='9200a744' name='zhp'/>
	<parameter type-id='bf9c30ee' name='proto'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	+ <function-decl name='zfs_unshare' mangled-name='zfs_unshare' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_unshare'>
	+ <parameter type-id='9200a744' name='zhp'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	<function-decl name='zfs_is_shared_proto' mangled-name='zfs_is_shared_proto' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_is_shared_proto'>
	<parameter type-id='9200a744' name='zhp'/>
	<parameter type-id='9b23c9ad' name='where'/>
	<parameter type-id='a7913f77' name='proto'/>
	<return type-id='7eb57c2d'/>
	</function-decl>
	<function-decl name='zfs_is_shared_nfs' mangled-name='zfs_is_shared_nfs' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_is_shared_nfs'>
	<parameter type-id='9200a744' name='zhp'/>
	<parameter type-id='9b23c9ad' name='where'/>
	<return type-id='c19b74c3'/>
	</function-decl>
	<function-decl name='zfs_is_shared_smb' mangled-name='zfs_is_shared_smb' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_is_shared_smb'>
	<parameter type-id='9200a744' name='zhp'/>
	<parameter type-id='9b23c9ad' name='where'/>
	<return type-id='c19b74c3'/>
	</function-decl>
	<function-decl name='zfs_commit_shares' mangled-name='zfs_commit_shares' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_commit_shares'>
	<parameter type-id='80f4b756' name='proto'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='zfs_shareall' mangled-name='zfs_shareall' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_shareall'>
	- <parameter type-id='9200a744' name='zhp'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	<function-decl name='zfs_unshareall_nfs' mangled-name='zfs_unshareall_nfs' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_unshareall_nfs'>
	<parameter type-id='9200a744' name='zhp'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='zfs_unshareall_smb' mangled-name='zfs_unshareall_smb' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_unshareall_smb'>
	<parameter type-id='9200a744' name='zhp'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='zfs_unshareall' mangled-name='zfs_unshareall' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_unshareall'>
	<parameter type-id='9200a744' name='zhp'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zfs_unshare' mangled-name='zfs_unshare' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_unshare'>
	- <parameter type-id='9200a744' name='zhp'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	<function-decl name='zfs_unshareall_bypath' mangled-name='zfs_unshareall_bypath' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_unshareall_bypath'>
	<parameter type-id='9200a744' name='zhp'/>
	<parameter type-id='80f4b756' name='mountpoint'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='zfs_unshareall_bytype' mangled-name='zfs_unshareall_bytype' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_unshareall_bytype'>
	<parameter type-id='9200a744' name='zhp'/>
	<parameter type-id='80f4b756' name='mountpoint'/>
	<parameter type-id='80f4b756' name='proto'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='libzfs_add_handle' mangled-name='libzfs_add_handle' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libzfs_add_handle'>
	<parameter type-id='77bf1784' name='cbp'/>
	<parameter type-id='9200a744' name='zhp'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='zfs_foreach_mountpoint' mangled-name='zfs_foreach_mountpoint' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_foreach_mountpoint'>
	<parameter type-id='b0382bb3' name='hdl'/>
	<parameter type-id='4507922a' name='handles'/>
	<parameter type-id='b59d7dce' name='num_handles'/>
	<parameter type-id='d8e49ab9' name='func'/>
	<parameter type-id='eaa32e2f' name='data'/>
	<parameter type-id='c19b74c3' name='parallel'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='zpool_enable_datasets' mangled-name='zpool_enable_datasets' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_enable_datasets'>
	<parameter type-id='4c81de99' name='zhp'/>
	<parameter type-id='80f4b756' name='mntopts'/>
	<parameter type-id='95e97e5e' name='flags'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zpool_disable_datasets' mangled-name='zpool_unmount_datasets' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_unmount_datasets'>
	+ <function-decl name='zpool_disable_datasets' mangled-name='zpool_disable_datasets' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_disable_datasets'>
	<parameter type-id='4c81de99' name='zhp'/>
	<parameter type-id='c19b74c3' name='force'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <var-decl name='proto_table' type-id='b2c36c9f' mangled-name='proto_table' visibility='default' elf-symbol-id='proto_table'/>
	- <var-decl name='nfs_only' type-id='79c9b3ac' mangled-name='nfs_only' visibility='default' elf-symbol-id='nfs_only'/>
	- <var-decl name='smb_only' type-id='79c9b3ac' mangled-name='smb_only' visibility='default' elf-symbol-id='smb_only'/>
	- <var-decl name='share_all_proto' type-id='7dc77b61' mangled-name='share_all_proto' visibility='default' elf-symbol-id='share_all_proto'/>
	- <function-decl name='do_unmount' mangled-name='do_unmount' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='do_unmount'>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='95e97e5e'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='tpool_dispatch' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='9cf59a50'/>
	- <parameter type-id='b7f9d8e6'/>
	- <parameter type-id='eaa32e2f'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	<function-decl name='fdopendir' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='95e97e5e'/>
	<return type-id='f09217ba'/>
	</function-decl>
	- <function-decl name='readdir64' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='f09217ba'/>
	- <return type-id='07b96073'/>
	- </function-decl>
	<function-decl name='closedir' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='f09217ba'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='statfs64' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='7fd094c8'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='do_mount' mangled-name='do_mount' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='do_mount'>
	- <parameter type-id='9200a744'/>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='26a90f95'/>
	- <parameter type-id='95e97e5e'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='mkdirp' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='d50d396c'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='sa_disable_share' mangled-name='sa_disable_share' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='sa_disable_share'>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='26a90f95'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='sa_errorstr' mangled-name='sa_errorstr' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='sa_errorstr'>
	- <parameter type-id='95e97e5e'/>
	- <return type-id='26a90f95'/>
	- </function-decl>
	- <function-decl name='sa_is_shared' mangled-name='sa_is_shared' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='sa_is_shared'>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='26a90f95'/>
	- <return type-id='c19b74c3'/>
	- </function-decl>
	- <function-decl name='sa_enable_share' mangled-name='sa_enable_share' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='sa_enable_share'>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='26a90f95'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='sa_validate_shareopts' mangled-name='sa_validate_shareopts' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='sa_validate_shareopts'>
	- <parameter type-id='26a90f95'/>
	- <parameter type-id='26a90f95'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='sa_commit_shares' mangled-name='sa_commit_shares' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='sa_commit_shares'>
	- <parameter type-id='80f4b756'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	- <function-decl name='rmdir' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='80f4b756'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='zfs_realloc' mangled-name='zfs_realloc' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_realloc'>
	- <parameter type-id='b0382bb3'/>
	- <parameter type-id='eaa32e2f'/>
	- <parameter type-id='b59d7dce'/>
	- <parameter type-id='b59d7dce'/>
	- <return type-id='eaa32e2f'/>
	+ <function-decl name='readdir64' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='f09217ba'/>
	+ <return type-id='07b96073'/>
	</function-decl>
	<function-decl name='qsort' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='b59d7dce'/>
	<parameter type-id='b59d7dce'/>
	<parameter type-id='aba7edd8'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='tpool_create' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='3502e3ff'/>
	- <parameter type-id='3502e3ff'/>
	- <parameter type-id='3502e3ff'/>
	- <parameter type-id='7347a39e'/>
	- <return type-id='9cf59a50'/>
	- </function-decl>
	- <function-decl name='tpool_wait' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='9cf59a50'/>
	- <return type-id='48b5725f'/>
	+ <function-decl name='statfs64' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='7fd094c8'/>
	+ <return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='tpool_destroy' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='9cf59a50'/>
	- <return type-id='48b5725f'/>
	+ <function-decl name='rmdir' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='80f4b756'/>
	+ <return type-id='95e97e5e'/>
	</function-decl>
	<function-type size-in-bits='64' id='c5c76c9c'>
	<parameter type-id='eaa32e2f'/>
	<return type-id='48b5725f'/>
	</function-type>
	</abi-instr>
	- <abi-instr version='1.0' address-size='64' path='libzfs_pool.c' language='LANG_C89'>
	+ <abi-instr address-size='64' path='libzfs_pool.c' language='LANG_C99'>
	<type-decl name='long long unsigned int' size-in-bits='64' id='3a47d82b'/>
	- <typedef-decl name='vdev_state_t' type-id='21566197' id='35acf840'/>
	+ <class-decl name='splitflags' size-in-bits='64' is-struct='yes' visibility='default' id='dc01bf52'>
	+ <data-member access='public' layout-offset-in-bits='0'>
	+ <var-decl name='dryrun' type-id='95e97e5e' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='1'>
	+ <var-decl name='import' type-id='95e97e5e' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='32'>
	+ <var-decl name='name_flags' type-id='95e97e5e' visibility='default'/>
	+ </data-member>
	+ </class-decl>
	+ <typedef-decl name='splitflags_t' type-id='dc01bf52' id='325c1e34'/>
	+ <class-decl name='trimflags' size-in-bits='192' is-struct='yes' visibility='default' id='8ef58008'>
	+ <data-member access='public' layout-offset-in-bits='0'>
	+ <var-decl name='fullpool' type-id='c19b74c3' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='32'>
	+ <var-decl name='secure' type-id='c19b74c3' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='64'>
	+ <var-decl name='wait' type-id='c19b74c3' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='128'>
	+ <var-decl name='rate' type-id='9c313c2d' visibility='default'/>
	+ </data-member>
	+ </class-decl>
	+ <typedef-decl name='trimflags_t' type-id='8ef58008' id='a093cbb8'/>
	+ <enum-decl name='zpool_status_t' naming-typedef-id='d3dd6294' id='5e770b40'>
	+ <underlying-type type-id='9cac1fee'/>
	+ <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_INCOMPATIBLE_FEAT' value='31'/>
	+ <enumerator name='ZPOOL_STATUS_OK' value='32'/>
	+ </enum-decl>
	+ <typedef-decl name='zpool_status_t' type-id='5e770b40' id='d3dd6294'/>
	+ <enum-decl name='zpool_compat_status_t' naming-typedef-id='901b78d1' id='20676925'>
	+ <underlying-type type-id='9cac1fee'/>
	+ <enumerator name='ZPOOL_COMPATIBILITY_OK' value='0'/>
	+ <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='20676925' id='901b78d1'/>
	+ <class-decl name='zpool_load_policy' size-in-bits='256' is-struct='yes' visibility='default' id='2f65b36f'>
	+ <data-member access='public' layout-offset-in-bits='0'>
	+ <var-decl name='zlp_rewind' type-id='8f92235e' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='64'>
	+ <var-decl name='zlp_maxmeta' type-id='9c313c2d' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='128'>
	+ <var-decl name='zlp_maxdata' type-id='9c313c2d' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='192'>
	+ <var-decl name='zlp_txg' type-id='9c313c2d' visibility='default'/>
	+ </data-member>
	+ </class-decl>
	+ <typedef-decl name='zpool_load_policy_t' type-id='2f65b36f' id='d11b7617'/>
	<enum-decl name='vdev_state' id='21566197'>
	<underlying-type type-id='9cac1fee'/>
	<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_aux_t' type-id='7f5bcca4' id='9d774e0b'/>
	+ <typedef-decl name='vdev_state_t' type-id='21566197' id='35acf840'/>
	<enum-decl name='vdev_aux' id='7f5bcca4'>
	<underlying-type type-id='9cac1fee'/>
	<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='pool_scan_func_t' type-id='1b092565' id='7313fbe2'/>
	+ <typedef-decl name='vdev_aux_t' type-id='7f5bcca4' id='9d774e0b'/>
	<enum-decl name='pool_scan_func' id='1b092565'>
	<underlying-type type-id='9cac1fee'/>
	<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_scrub_cmd_t' type-id='a1474cbd' id='b51cf3c2'/>
	+ <typedef-decl name='pool_scan_func_t' type-id='1b092565' id='7313fbe2'/>
	<enum-decl name='pool_scrub_cmd' id='a1474cbd'>
	<underlying-type type-id='9cac1fee'/>
	<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_trim_func_t' type-id='54ed608a' id='b1146b8d'/>
	- <enum-decl name='pool_trim_func' id='54ed608a'>
	+ <typedef-decl name='pool_scrub_cmd_t' type-id='a1474cbd' id='b51cf3c2'/>
	+ <enum-decl name='zpool_errata' id='d9abbf54'>
	<underlying-type type-id='9cac1fee'/>
	- <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'/>
	+ <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='trimflags_t' type-id='8ef58008' id='a093cbb8'/>
	- <class-decl name='trimflags' size-in-bits='192' is-struct='yes' visibility='default' id='8ef58008'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='fullpool' type-id='c19b74c3' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='32'>
	- <var-decl name='secure' type-id='c19b74c3' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='wait' type-id='c19b74c3' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='rate' type-id='9c313c2d' visibility='default'/>
	- </data-member>
	- </class-decl>
	- <typedef-decl name='pool_initialize_func_t' type-id='5c246ad4' id='7063e1ab'/>
	+ <typedef-decl name='zpool_errata_t' type-id='d9abbf54' id='688c495b'/>
	<enum-decl name='pool_initialize_func' id='5c246ad4'>
	<underlying-type type-id='9cac1fee'/>
	<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='zpool_wait_activity_t' type-id='08f5ca1e' id='73446457'/>
	- <enum-decl name='__anonymous_enum__' is-anonymous='yes' id='08f5ca1e'>
	+ <typedef-decl name='pool_initialize_func_t' type-id='5c246ad4' id='7063e1ab'/>
	+ <enum-decl name='pool_trim_func' id='54ed608a'>
	+ <underlying-type type-id='9cac1fee'/>
	+ <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='54ed608a' id='b1146b8d'/>
	+ <enum-decl name='zpool_wait_activity_t' naming-typedef-id='73446457' id='849338e3'>
	<underlying-type type-id='9cac1fee'/>
	<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_compat_status_t' type-id='40ed39d6' id='901b78d1'/>
	- <enum-decl name='__anonymous_enum__1' is-anonymous='yes' id='40ed39d6'>
	- <underlying-type type-id='9cac1fee'/>
	- <enumerator name='ZPOOL_COMPATIBILITY_OK' value='0'/>
	- <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='splitflags_t' type-id='dc01bf52' id='325c1e34'/>
	- <class-decl name='splitflags' size-in-bits='64' is-struct='yes' visibility='default' id='dc01bf52'>
	- <data-member access='public' layout-offset-in-bits='31'>
	- <var-decl name='dryrun' type-id='95e97e5e' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='30'>
	- <var-decl name='import' type-id='95e97e5e' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='32'>
	- <var-decl name='name_flags' type-id='95e97e5e' visibility='default'/>
	- </data-member>
	- </class-decl>
	- <typedef-decl name='spa_feature_t' type-id='33ecb627' id='d6618c78'/>
	+ <typedef-decl name='zpool_wait_activity_t' type-id='849338e3' id='73446457'/>
	<enum-decl name='spa_feature' id='33ecb627'>
	<underlying-type type-id='9cac1fee'/>
	<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='zpool_status_t' type-id='3fed3841' id='d3dd6294'/>
	- <enum-decl name='__anonymous_enum__2' is-anonymous='yes' id='3fed3841'>
	- <underlying-type type-id='9cac1fee'/>
	- <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_INCOMPATIBLE_FEAT' value='31'/>
	- <enumerator name='ZPOOL_STATUS_OK' value='32'/>
	- </enum-decl>
	- <typedef-decl name='zpool_errata_t' type-id='d9abbf54' id='688c495b'/>
	- <enum-decl name='zpool_errata' id='d9abbf54'>
	- <underlying-type type-id='9cac1fee'/>
	- <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_load_policy_t' type-id='2f65b36f' id='d11b7617'/>
	- <class-decl name='zpool_load_policy' size-in-bits='256' is-struct='yes' visibility='default' id='2f65b36f'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='zlp_rewind' type-id='8f92235e' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='zlp_maxmeta' type-id='9c313c2d' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='zlp_maxdata' type-id='9c313c2d' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='192'>
	- <var-decl name='zlp_txg' type-id='9c313c2d' visibility='default'/>
	- </data-member>
	- </class-decl>
	+ <typedef-decl name='spa_feature_t' type-id='33ecb627' id='d6618c78'/>
	<qualified-type-def type-id='8e8d4be3' const='yes' id='693c3853'/>
	<pointer-type-def type-id='693c3853' size-in-bits='64' id='22cce67b'/>
	<pointer-type-def type-id='d6618c78' size-in-bits='64' id='a8425263'/>
	+ <qualified-type-def type-id='62f7a03d' restrict='yes' id='f1cadedf'/>
	<pointer-type-def type-id='a093cbb8' size-in-bits='64' id='b13f38c3'/>
	<pointer-type-def type-id='35acf840' size-in-bits='64' id='17f3480d'/>
	<pointer-type-def type-id='688c495b' size-in-bits='64' id='cec6f2e4'/>
	<pointer-type-def type-id='d11b7617' size-in-bits='64' id='23432aaa'/>
	- <function-decl name='zpool_props_refresh' mangled-name='zpool_props_refresh' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_props_refresh'>
	- <parameter type-id='4c81de99' name='zhp'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='zpool_state_to_name' mangled-name='zpool_state_to_name' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_state_to_name'>
	- <parameter type-id='35acf840' name='state'/>
	- <parameter type-id='9d774e0b' name='aux'/>
	- <return type-id='80f4b756'/>
	+ <function-decl name='zpool_get_handle' mangled-name='zpool_get_handle' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_get_handle'>
	+ <parameter type-id='4c81de99'/>
	+ <return type-id='b0382bb3'/>
	</function-decl>
	- <function-decl name='zpool_pool_state_to_name' mangled-name='zpool_pool_state_to_name' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_pool_state_to_name'>
	- <parameter type-id='084a08a3' name='state'/>
	+ <function-decl name='zpool_prop_to_name' mangled-name='zpool_prop_to_name' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_prop_to_name'>
	+ <parameter type-id='5d0c23fb'/>
	<return type-id='80f4b756'/>
	</function-decl>
	- <function-decl name='zpool_get_state' mangled-name='zpool_get_state' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_get_state'>
	- <parameter type-id='4c81de99' name='zhp'/>
	- <return type-id='95e97e5e'/>
	+ <function-decl name='zpool_get_status' mangled-name='zpool_get_status' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_get_status'>
	+ <parameter type-id='4c81de99'/>
	+ <parameter type-id='9b23c9ad'/>
	+ <parameter type-id='cec6f2e4'/>
	+ <return type-id='d3dd6294'/>
	</function-decl>
	- <function-decl name='zpool_get_state_str' mangled-name='zpool_get_state_str' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_get_state_str'>
	- <parameter type-id='4c81de99' name='zhp'/>
	+ <function-decl name='zpool_prop_default_string' mangled-name='zpool_prop_default_string' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_prop_default_string'>
	+ <parameter type-id='5d0c23fb'/>
	<return type-id='80f4b756'/>
	</function-decl>
	- <function-decl name='zpool_expand_proplist' mangled-name='zpool_expand_proplist' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_expand_proplist'>
	- <parameter type-id='4c81de99' name='zhp'/>
	- <parameter type-id='e4378506' name='plp'/>
	- <parameter type-id='c19b74c3' name='literal'/>
	- <return type-id='95e97e5e'/>
	+ <function-decl name='zpool_prop_default_numeric' mangled-name='zpool_prop_default_numeric' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_prop_default_numeric'>
	+ <parameter type-id='5d0c23fb'/>
	+ <return type-id='9c313c2d'/>
	</function-decl>
	- <function-decl name='zpool_is_draid_spare' mangled-name='zpool_is_draid_spare' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_is_draid_spare'>
	- <parameter type-id='80f4b756' name='name'/>
	- <return type-id='c19b74c3'/>
	+ <function-decl name='lzc_initialize' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='7063e1ab'/>
	+ <parameter type-id='5ce45b60'/>
	+ <parameter type-id='857bb57e'/>
	+ <return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zpool_destroy' mangled-name='zpool_destroy' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_destroy'>
	- <parameter type-id='4c81de99' name='zhp'/>
	- <parameter type-id='80f4b756' name='log_str'/>
	+ <function-decl name='lzc_trim' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='b1146b8d'/>
	+ <parameter type-id='9c313c2d'/>
	+ <parameter type-id='c19b74c3'/>
	+ <parameter type-id='5ce45b60'/>
	+ <parameter type-id='857bb57e'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zpool_checkpoint' mangled-name='zpool_checkpoint' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_checkpoint'>
	- <parameter type-id='4c81de99' name='zhp'/>
	+ <function-decl name='lzc_sync' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='5ce45b60'/>
	+ <parameter type-id='857bb57e'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zpool_discard_checkpoint' mangled-name='zpool_discard_checkpoint' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_discard_checkpoint'>
	- <parameter type-id='4c81de99' name='zhp'/>
	+ <function-decl name='lzc_reopen' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='c19b74c3'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zpool_add' mangled-name='zpool_add' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_add'>
	- <parameter type-id='4c81de99' name='zhp'/>
	- <parameter type-id='5ce45b60' name='nvroot'/>
	+ <function-decl name='lzc_pool_checkpoint' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='80f4b756'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zpool_export' mangled-name='zpool_export' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_export'>
	- <parameter type-id='4c81de99' name='zhp'/>
	- <parameter type-id='c19b74c3' name='force'/>
	- <parameter type-id='80f4b756' name='log_str'/>
	+ <function-decl name='lzc_pool_checkpoint_discard' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='80f4b756'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zpool_export_force' mangled-name='zpool_export_force' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_export_force'>
	- <parameter type-id='4c81de99' name='zhp'/>
	- <parameter type-id='80f4b756' name='log_str'/>
	+ <function-decl name='lzc_wait' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='73446457'/>
	+ <parameter type-id='37e3bd22'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zpool_explain_recover' mangled-name='zpool_explain_recover' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_explain_recover'>
	- <parameter type-id='b0382bb3' name='hdl'/>
	- <parameter type-id='80f4b756' name='name'/>
	- <parameter type-id='95e97e5e' name='reason'/>
	- <parameter type-id='5ce45b60' name='config'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	- <function-decl name='zpool_print_unsup_feat' mangled-name='zpool_print_unsup_feat' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_print_unsup_feat'>
	- <parameter type-id='5ce45b60' name='config'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	- <function-decl name='zpool_scan' mangled-name='zpool_scan' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_scan'>
	- <parameter type-id='4c81de99' name='zhp'/>
	- <parameter type-id='7313fbe2' name='func'/>
	- <parameter type-id='b51cf3c2' name='cmd'/>
	+ <function-decl name='lzc_wait_tag' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='73446457'/>
	+ <parameter type-id='9c313c2d'/>
	+ <parameter type-id='37e3bd22'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zpool_find_vdev_by_physpath' mangled-name='zpool_find_vdev_by_physpath' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_find_vdev_by_physpath'>
	- <parameter type-id='4c81de99' name='zhp'/>
	- <parameter type-id='80f4b756' name='ppath'/>
	- <parameter type-id='37e3bd22' name='avail_spare'/>
	- <parameter type-id='37e3bd22' name='l2cache'/>
	- <parameter type-id='37e3bd22' name='log'/>
	- <return type-id='5ce45b60'/>
	+ <function-decl name='lzc_set_bootenv' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='22cce67b'/>
	+ <return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zpool_find_vdev' mangled-name='zpool_find_vdev' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_find_vdev'>
	- <parameter type-id='4c81de99' name='zhp'/>
	- <parameter type-id='80f4b756' name='path'/>
	- <parameter type-id='37e3bd22' name='avail_spare'/>
	- <parameter type-id='37e3bd22' name='l2cache'/>
	- <parameter type-id='37e3bd22' name='log'/>
	- <return type-id='5ce45b60'/>
	+ <function-decl name='lzc_get_bootenv' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='857bb57e'/>
	+ <return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zpool_trim' mangled-name='zpool_trim' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_trim'>
	- <parameter type-id='4c81de99' name='zhp'/>
	- <parameter type-id='b1146b8d' name='cmd_type'/>
	- <parameter type-id='5ce45b60' name='vds'/>
	- <parameter type-id='b13f38c3' name='trim_flags'/>
	+ <function-decl name='zpool_standard_error' mangled-name='zpool_standard_error' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_standard_error'>
	+ <parameter type-id='b0382bb3'/>
	+ <parameter type-id='95e97e5e'/>
	+ <parameter type-id='80f4b756'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zpool_initialize' mangled-name='zpool_initialize' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_initialize'>
	- <parameter type-id='4c81de99' name='zhp'/>
	- <parameter type-id='7063e1ab' name='cmd_type'/>
	- <parameter type-id='5ce45b60' name='vds'/>
	+ <function-decl name='zpool_standard_error_fmt' mangled-name='zpool_standard_error_fmt' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_standard_error_fmt'>
	+ <parameter type-id='b0382bb3'/>
	+ <parameter type-id='95e97e5e'/>
	+ <parameter type-id='80f4b756'/>
	+ <parameter is-variadic='yes'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zpool_initialize_wait' mangled-name='zpool_initialize_wait' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_initialize_wait'>
	- <parameter type-id='4c81de99' name='zhp'/>
	- <parameter type-id='7063e1ab' name='cmd_type'/>
	- <parameter type-id='5ce45b60' name='vds'/>
	+ <function-decl name='zpool_relabel_disk' mangled-name='zpool_relabel_disk' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_relabel_disk'>
	+ <parameter type-id='b0382bb3'/>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='80f4b756'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zpool_get_physpath' mangled-name='zpool_get_physpath' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_get_physpath'>
	- <parameter type-id='4c81de99' name='zhp'/>
	- <parameter type-id='26a90f95' name='physpath'/>
	- <parameter type-id='b59d7dce' name='phypath_size'/>
	+ <function-decl name='zfs_resolve_shortname' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='26a90f95'/>
	+ <parameter type-id='b59d7dce'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zpool_vdev_path_to_guid' mangled-name='zpool_vdev_path_to_guid' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_vdev_path_to_guid'>
	- <parameter type-id='4c81de99' name='zhp'/>
	- <parameter type-id='80f4b756' name='path'/>
	- <return type-id='9c313c2d'/>
	+ <function-decl name='zfs_strip_partition' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='26a90f95'/>
	+ <return type-id='26a90f95'/>
	</function-decl>
	- <function-decl name='zpool_vdev_online' mangled-name='zpool_vdev_online' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_vdev_online'>
	- <parameter type-id='4c81de99' name='zhp'/>
	- <parameter type-id='80f4b756' name='path'/>
	- <parameter type-id='95e97e5e' name='flags'/>
	- <parameter type-id='17f3480d' name='newstate'/>
	- <return type-id='95e97e5e'/>
	+ <function-decl name='zfs_strip_path' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='26a90f95'/>
	+ <return type-id='26a90f95'/>
	</function-decl>
	- <function-decl name='zpool_vdev_offline' mangled-name='zpool_vdev_offline' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_vdev_offline'>
	- <parameter type-id='4c81de99' name='zhp'/>
	- <parameter type-id='80f4b756' name='path'/>
	- <parameter type-id='c19b74c3' name='istmp'/>
	+ <function-decl name='zfs_strcmp_pathname' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='95e97e5e'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zpool_vdev_fault' mangled-name='zpool_vdev_fault' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_vdev_fault'>
	- <parameter type-id='4c81de99' name='zhp'/>
	- <parameter type-id='9c313c2d' name='guid'/>
	- <parameter type-id='9d774e0b' name='aux'/>
	+ <function-decl name='zpool_history_unpack' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='26a90f95'/>
	+ <parameter type-id='9c313c2d'/>
	+ <parameter type-id='5d6479ae'/>
	+ <parameter type-id='75be733c'/>
	+ <parameter type-id='4dd26a40'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zpool_vdev_degrade' mangled-name='zpool_vdev_degrade' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_vdev_degrade'>
	- <parameter type-id='4c81de99' name='zhp'/>
	- <parameter type-id='9c313c2d' name='guid'/>
	- <parameter type-id='9d774e0b' name='aux'/>
	- <return type-id='95e97e5e'/>
	+ <function-decl name='zpool_name_to_prop' mangled-name='zpool_name_to_prop' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_name_to_prop'>
	+ <parameter type-id='80f4b756'/>
	+ <return type-id='5d0c23fb'/>
	</function-decl>
	- <function-decl name='zpool_vdev_detach' mangled-name='zpool_vdev_detach' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_vdev_detach'>
	- <parameter type-id='4c81de99' name='zhp'/>
	- <parameter type-id='80f4b756' name='path'/>
	- <return type-id='95e97e5e'/>
	+ <function-decl name='zpool_prop_readonly' mangled-name='zpool_prop_readonly' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_prop_readonly'>
	+ <parameter type-id='5d0c23fb'/>
	+ <return type-id='c19b74c3'/>
	</function-decl>
	- <function-decl name='zpool_vdev_remove' mangled-name='zpool_vdev_remove' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_vdev_remove'>
	- <parameter type-id='4c81de99' name='zhp'/>
	- <parameter type-id='80f4b756' name='path'/>
	- <return type-id='95e97e5e'/>
	+ <function-decl name='zpool_prop_setonce' mangled-name='zpool_prop_setonce' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_prop_setonce'>
	+ <parameter type-id='5d0c23fb'/>
	+ <return type-id='c19b74c3'/>
	</function-decl>
	- <function-decl name='zpool_vdev_remove_cancel' mangled-name='zpool_vdev_remove_cancel' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_vdev_remove_cancel'>
	- <parameter type-id='4c81de99' name='zhp'/>
	- <return type-id='95e97e5e'/>
	+ <function-decl name='zpool_prop_feature' mangled-name='zpool_prop_feature' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_prop_feature'>
	+ <parameter type-id='80f4b756'/>
	+ <return type-id='c19b74c3'/>
	</function-decl>
	- <function-decl name='zpool_vdev_indirect_size' mangled-name='zpool_vdev_indirect_size' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_vdev_indirect_size'>
	- <parameter type-id='4c81de99' name='zhp'/>
	- <parameter type-id='80f4b756' name='path'/>
	- <parameter type-id='5d6479ae' name='sizep'/>
	+ <function-decl name='zpool_prop_index_to_string' mangled-name='zpool_prop_index_to_string' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_prop_index_to_string'>
	+ <parameter type-id='5d0c23fb'/>
	+ <parameter type-id='9c313c2d'/>
	+ <parameter type-id='7d3cd834'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zpool_clear' mangled-name='zpool_clear' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_clear'>
	- <parameter type-id='4c81de99' name='zhp'/>
	- <parameter type-id='80f4b756' name='path'/>
	- <parameter type-id='5ce45b60' name='rewindnvl'/>
	+ <function-decl name='nvlist_add_uint8_array' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='5ce45b60'/>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='ae3e8ca6'/>
	+ <parameter type-id='3502e3ff'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zpool_vdev_clear' mangled-name='zpool_vdev_clear' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_vdev_clear'>
	- <parameter type-id='4c81de99' name='zhp'/>
	- <parameter type-id='9c313c2d' name='guid'/>
	+ <function-decl name='nvlist_add_nvlist_array' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='5ce45b60'/>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='857bb57e'/>
	+ <parameter type-id='3502e3ff'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zpool_reguid' mangled-name='zpool_reguid' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_reguid'>
	- <parameter type-id='4c81de99' name='zhp'/>
	- <return type-id='95e97e5e'/>
	+ <function-decl name='fnvlist_add_boolean_value' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='5ce45b60'/>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='c19b74c3'/>
	+ <return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='zpool_reopen_one' mangled-name='zpool_reopen_one' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_reopen_one'>
	- <parameter type-id='4c81de99' name='zhp'/>
	- <parameter type-id='eaa32e2f' name='data'/>
	- <return type-id='95e97e5e'/>
	+ <function-decl name='fnvlist_add_int64' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='5ce45b60'/>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='9da381c4'/>
	+ <return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='zpool_sync_one' mangled-name='zpool_sync_one' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_sync_one'>
	- <parameter type-id='4c81de99' name='zhp'/>
	- <parameter type-id='eaa32e2f' name='data'/>
	- <return type-id='95e97e5e'/>
	+ <function-decl name='fnvlist_lookup_uint64' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='5ce45b60'/>
	+ <parameter type-id='80f4b756'/>
	+ <return type-id='9c313c2d'/>
	</function-decl>
	- <function-decl name='zpool_vdev_name' mangled-name='zpool_vdev_name' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_vdev_name'>
	- <parameter type-id='b0382bb3' name='hdl'/>
	- <parameter type-id='4c81de99' name='zhp'/>
	- <parameter type-id='5ce45b60' name='nv'/>
	- <parameter type-id='95e97e5e' name='name_flags'/>
	- <return type-id='26a90f95'/>
	+ <function-decl name='fnvpair_value_int64' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='3fa542f0'/>
	+ <return type-id='9da381c4'/>
	</function-decl>
	- <function-decl name='zpool_vdev_attach' mangled-name='zpool_vdev_attach' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_vdev_attach'>
	- <parameter type-id='4c81de99' name='zhp'/>
	- <parameter type-id='80f4b756' name='old_disk'/>
	- <parameter type-id='80f4b756' name='new_disk'/>
	- <parameter type-id='5ce45b60' name='nvroot'/>
	- <parameter type-id='95e97e5e' name='replacing'/>
	- <parameter type-id='c19b74c3' name='rebuild'/>
	+ <function-decl name='zfeature_is_supported' mangled-name='zfeature_is_supported' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfeature_is_supported'>
	+ <parameter type-id='80f4b756'/>
	+ <return type-id='c19b74c3'/>
	+ </function-decl>
	+ <function-decl name='zfeature_lookup_guid' mangled-name='zfeature_lookup_guid' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfeature_lookup_guid'>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='a8425263'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zpool_get_errlog' mangled-name='zpool_get_errlog' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_get_errlog'>
	- <parameter type-id='4c81de99' name='zhp'/>
	- <parameter type-id='857bb57e' name='nverrlistp'/>
	+ <function-decl name='zfeature_lookup_name' mangled-name='zfeature_lookup_name' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfeature_lookup_name'>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='a8425263'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='zpool_get_load_policy' mangled-name='zpool_get_load_policy' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_get_load_policy'>
	+ <parameter type-id='5ce45b60'/>
	+ <parameter type-id='23432aaa'/>
	+ <return type-id='48b5725f'/>
	+ </function-decl>
	+ <function-decl name='pool_namecheck' mangled-name='pool_namecheck' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='pool_namecheck'>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='053457bd'/>
	+ <parameter type-id='26a90f95'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zpool_upgrade' mangled-name='zpool_upgrade' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_upgrade'>
	+ <function-decl name='zpool_prop_get_type' mangled-name='zpool_prop_get_type' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_prop_get_type'>
	+ <parameter type-id='5d0c23fb'/>
	+ <return type-id='31429eff'/>
	+ </function-decl>
	+ <function-decl name='get_system_hostid' visibility='default' binding='global' size-in-bits='64'>
	+ <return type-id='7359adad'/>
	+ </function-decl>
	+ <function-decl name='zpool_props_refresh' mangled-name='zpool_props_refresh' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_props_refresh'>
	<parameter type-id='4c81de99' name='zhp'/>
	- <parameter type-id='9c313c2d' name='new_version'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zfs_save_arguments' mangled-name='zfs_save_arguments' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_save_arguments'>
	- <parameter type-id='95e97e5e' name='argc'/>
	- <parameter type-id='9b23c9ad' name='argv'/>
	- <parameter type-id='26a90f95' name='string'/>
	- <parameter type-id='95e97e5e' name='len'/>
	- <return type-id='48b5725f'/>
	+ <function-decl name='zpool_state_to_name' mangled-name='zpool_state_to_name' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_state_to_name'>
	+ <parameter type-id='35acf840' name='state'/>
	+ <parameter type-id='9d774e0b' name='aux'/>
	+ <return type-id='80f4b756'/>
	</function-decl>
	- <function-decl name='zpool_log_history' mangled-name='zpool_log_history' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_log_history'>
	- <parameter type-id='b0382bb3' name='hdl'/>
	- <parameter type-id='80f4b756' name='message'/>
	- <return type-id='95e97e5e'/>
	+ <function-decl name='zpool_pool_state_to_name' mangled-name='zpool_pool_state_to_name' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_pool_state_to_name'>
	+ <parameter type-id='084a08a3' name='state'/>
	+ <return type-id='80f4b756'/>
	</function-decl>
	- <function-decl name='zpool_get_history' mangled-name='zpool_get_history' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_get_history'>
	+ <function-decl name='zpool_get_state_str' mangled-name='zpool_get_state_str' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_get_state_str'>
	<parameter type-id='4c81de99' name='zhp'/>
	- <parameter type-id='857bb57e' name='nvhisp'/>
	- <parameter type-id='5d6479ae' name='off'/>
	- <parameter type-id='37e3bd22' name='eof'/>
	+ <return type-id='80f4b756'/>
	+ </function-decl>
	+ <function-decl name='zpool_set_prop' mangled-name='zpool_set_prop' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_set_prop'>
	+ <parameter type-id='4c81de99' name='zhp'/>
	+ <parameter type-id='80f4b756' name='propname'/>
	+ <parameter type-id='80f4b756' name='propval'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zpool_events_next' mangled-name='zpool_events_next' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_events_next'>
	- <parameter type-id='b0382bb3' name='hdl'/>
	- <parameter type-id='857bb57e' name='nvp'/>
	- <parameter type-id='7292109c' name='dropped'/>
	- <parameter type-id='f0981eeb' name='flags'/>
	- <parameter type-id='95e97e5e' name='zevent_fd'/>
	+ <function-decl name='zpool_expand_proplist' mangled-name='zpool_expand_proplist' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_expand_proplist'>
	+ <parameter type-id='4c81de99' name='zhp'/>
	+ <parameter type-id='e4378506' name='plp'/>
	+ <parameter type-id='c19b74c3' name='literal'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zpool_events_clear' mangled-name='zpool_events_clear' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_events_clear'>
	- <parameter type-id='b0382bb3' name='hdl'/>
	- <parameter type-id='7292109c' name='count'/>
	+ <function-decl name='zpool_get_state' mangled-name='zpool_get_state' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_get_state'>
	+ <parameter type-id='4c81de99' name='zhp'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zpool_events_seek' mangled-name='zpool_events_seek' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_events_seek'>
	+ <function-decl name='zpool_is_draid_spare' mangled-name='zpool_is_draid_spare' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_is_draid_spare'>
	+ <parameter type-id='80f4b756' name='name'/>
	+ <return type-id='c19b74c3'/>
	+ </function-decl>
	+ <function-decl name='zpool_create' mangled-name='zpool_create' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_create'>
	<parameter type-id='b0382bb3' name='hdl'/>
	- <parameter type-id='9c313c2d' name='eid'/>
	- <parameter type-id='95e97e5e' name='zevent_fd'/>
	+ <parameter type-id='80f4b756' name='pool'/>
	+ <parameter type-id='5ce45b60' name='nvroot'/>
	+ <parameter type-id='5ce45b60' name='props'/>
	+ <parameter type-id='5ce45b60' name='fsprops'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zpool_obj_to_path' mangled-name='zpool_obj_to_path' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_obj_to_path'>
	- <parameter type-id='4c81de99' name='zhp'/>
	- <parameter type-id='9c313c2d' name='dsobj'/>
	- <parameter type-id='9c313c2d' name='obj'/>
	- <parameter type-id='26a90f95' name='pathname'/>
	- <parameter type-id='b59d7dce' name='len'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	- <function-decl name='zpool_obj_to_path_ds' mangled-name='zpool_obj_to_path_ds' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_obj_to_path_ds'>
	+ <function-decl name='zpool_destroy' mangled-name='zpool_destroy' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_destroy'>
	<parameter type-id='4c81de99' name='zhp'/>
	- <parameter type-id='9c313c2d' name='dsobj'/>
	- <parameter type-id='9c313c2d' name='obj'/>
	- <parameter type-id='26a90f95' name='pathname'/>
	- <parameter type-id='b59d7dce' name='len'/>
	- <return type-id='48b5725f'/>
	+ <parameter type-id='80f4b756' name='log_str'/>
	+ <return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zpool_wait_status' mangled-name='zpool_wait_status' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_wait_status'>
	+ <function-decl name='zpool_checkpoint' mangled-name='zpool_checkpoint' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_checkpoint'>
	<parameter type-id='4c81de99' name='zhp'/>
	- <parameter type-id='73446457' name='activity'/>
	- <parameter type-id='37e3bd22' name='missing'/>
	- <parameter type-id='37e3bd22' name='waited'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zpool_wait' mangled-name='zpool_wait' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_wait'>
	+ <function-decl name='zpool_discard_checkpoint' mangled-name='zpool_discard_checkpoint' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_discard_checkpoint'>
	<parameter type-id='4c81de99' name='zhp'/>
	- <parameter type-id='73446457' name='activity'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zpool_set_bootenv' mangled-name='zpool_set_bootenv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_set_bootenv'>
	+ <function-decl name='zpool_add' mangled-name='zpool_add' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_add'>
	<parameter type-id='4c81de99' name='zhp'/>
	- <parameter type-id='22cce67b' name='envmap'/>
	+ <parameter type-id='5ce45b60' name='nvroot'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zpool_get_bootenv' mangled-name='zpool_get_bootenv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_get_bootenv'>
	+ <function-decl name='zpool_export' mangled-name='zpool_export' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_export'>
	<parameter type-id='4c81de99' name='zhp'/>
	- <parameter type-id='857bb57e' name='nvlp'/>
	+ <parameter type-id='c19b74c3' name='force'/>
	+ <parameter type-id='80f4b756' name='log_str'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zpool_load_compat' mangled-name='zpool_load_compat' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_load_compat'>
	- <parameter type-id='80f4b756' name='compat'/>
	- <parameter type-id='37e3bd22' name='features'/>
	- <parameter type-id='26a90f95' name='report'/>
	- <parameter type-id='b59d7dce' name='rlen'/>
	- <return type-id='901b78d1'/>
	- </function-decl>
	- <function-decl name='zpool_set_prop' mangled-name='zpool_set_prop' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_set_prop'>
	+ <function-decl name='zpool_export_force' mangled-name='zpool_export_force' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_export_force'>
	<parameter type-id='4c81de99' name='zhp'/>
	- <parameter type-id='80f4b756' name='propname'/>
	- <parameter type-id='80f4b756' name='propval'/>
	+ <parameter type-id='80f4b756' name='log_str'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zpool_create' mangled-name='zpool_create' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_create'>
	+ <function-decl name='zpool_explain_recover' mangled-name='zpool_explain_recover' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_explain_recover'>
	<parameter type-id='b0382bb3' name='hdl'/>
	- <parameter type-id='80f4b756' name='pool'/>
	- <parameter type-id='5ce45b60' name='nvroot'/>
	- <parameter type-id='5ce45b60' name='props'/>
	- <parameter type-id='5ce45b60' name='fsprops'/>
	+ <parameter type-id='80f4b756' name='name'/>
	+ <parameter type-id='95e97e5e' name='reason'/>
	+ <parameter type-id='5ce45b60' name='config'/>
	+ <return type-id='48b5725f'/>
	+ </function-decl>
	+ <function-decl name='zpool_import' mangled-name='zpool_import' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_import'>
	+ <parameter type-id='b0382bb3' name='hdl'/>
	+ <parameter type-id='5ce45b60' name='config'/>
	+ <parameter type-id='80f4b756' name='newname'/>
	+ <parameter type-id='26a90f95' name='altroot'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	+ <function-decl name='zpool_print_unsup_feat' mangled-name='zpool_print_unsup_feat' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_print_unsup_feat'>
	+ <parameter type-id='5ce45b60' name='config'/>
	+ <return type-id='48b5725f'/>
	+ </function-decl>
	<function-decl name='zpool_import_props' mangled-name='zpool_import_props' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_import_props'>
	<parameter type-id='b0382bb3' name='hdl'/>
	<parameter type-id='5ce45b60' name='config'/>
	<parameter type-id='80f4b756' name='newname'/>
	<parameter type-id='5ce45b60' name='props'/>
	<parameter type-id='95e97e5e' name='flags'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zpool_import' mangled-name='zpool_import' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_import'>
	- <parameter type-id='b0382bb3' name='hdl'/>
	- <parameter type-id='5ce45b60' name='config'/>
	- <parameter type-id='80f4b756' name='newname'/>
	- <parameter type-id='26a90f95' name='altroot'/>
	+ <function-decl name='zpool_initialize' mangled-name='zpool_initialize' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_initialize'>
	+ <parameter type-id='4c81de99' name='zhp'/>
	+ <parameter type-id='7063e1ab' name='cmd_type'/>
	+ <parameter type-id='5ce45b60' name='vds'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zpool_vdev_split' mangled-name='zpool_vdev_split' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_vdev_split'>
	+ <function-decl name='zpool_initialize_wait' mangled-name='zpool_initialize_wait' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_initialize_wait'>
	<parameter type-id='4c81de99' name='zhp'/>
	- <parameter type-id='26a90f95' name='newname'/>
	- <parameter type-id='857bb57e' name='newroot'/>
	- <parameter type-id='5ce45b60' name='props'/>
	- <parameter type-id='325c1e34' name='flags'/>
	+ <parameter type-id='7063e1ab' name='cmd_type'/>
	+ <parameter type-id='5ce45b60' name='vds'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zpool_standard_error_fmt' mangled-name='zpool_standard_error_fmt' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_standard_error_fmt'>
	- <parameter type-id='b0382bb3'/>
	- <parameter type-id='95e97e5e'/>
	- <parameter type-id='80f4b756'/>
	- <parameter is-variadic='yes'/>
	+ <function-decl name='zpool_trim' mangled-name='zpool_trim' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_trim'>
	+ <parameter type-id='4c81de99' name='zhp'/>
	+ <parameter type-id='b1146b8d' name='cmd_type'/>
	+ <parameter type-id='5ce45b60' name='vds'/>
	+ <parameter type-id='b13f38c3' name='trim_flags'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='memcmp' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='eaa32e2f'/>
	- <parameter type-id='eaa32e2f'/>
	- <parameter type-id='b59d7dce'/>
	+ <function-decl name='zpool_scan' mangled-name='zpool_scan' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_scan'>
	+ <parameter type-id='4c81de99' name='zhp'/>
	+ <parameter type-id='7313fbe2' name='func'/>
	+ <parameter type-id='b51cf3c2' name='cmd'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zpool_prop_to_name' mangled-name='zpool_prop_to_name' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_prop_to_name'>
	- <parameter type-id='5d0c23fb'/>
	- <return type-id='80f4b756'/>
	+ <function-decl name='zpool_find_vdev_by_physpath' mangled-name='zpool_find_vdev_by_physpath' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_find_vdev_by_physpath'>
	+ <parameter type-id='4c81de99' name='zhp'/>
	+ <parameter type-id='80f4b756' name='ppath'/>
	+ <parameter type-id='37e3bd22' name='avail_spare'/>
	+ <parameter type-id='37e3bd22' name='l2cache'/>
	+ <parameter type-id='37e3bd22' name='log'/>
	+ <return type-id='5ce45b60'/>
	</function-decl>
	- <function-decl name='zpool_prop_default_string' mangled-name='zpool_prop_default_string' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_prop_default_string'>
	- <parameter type-id='5d0c23fb'/>
	- <return type-id='80f4b756'/>
	+ <function-decl name='zpool_find_vdev' mangled-name='zpool_find_vdev' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_find_vdev'>
	+ <parameter type-id='4c81de99' name='zhp'/>
	+ <parameter type-id='80f4b756' name='path'/>
	+ <parameter type-id='37e3bd22' name='avail_spare'/>
	+ <parameter type-id='37e3bd22' name='l2cache'/>
	+ <parameter type-id='37e3bd22' name='log'/>
	+ <return type-id='5ce45b60'/>
	</function-decl>
	- <function-decl name='fnvpair_value_int64' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='3fa542f0'/>
	- <return type-id='9da381c4'/>
	+ <function-decl name='zpool_get_physpath' mangled-name='zpool_get_physpath' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_get_physpath'>
	+ <parameter type-id='4c81de99' name='zhp'/>
	+ <parameter type-id='26a90f95' name='physpath'/>
	+ <parameter type-id='b59d7dce' name='phypath_size'/>
	+ <return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zpool_prop_default_numeric' mangled-name='zpool_prop_default_numeric' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_prop_default_numeric'>
	- <parameter type-id='5d0c23fb'/>
	+ <function-decl name='zpool_vdev_path_to_guid' mangled-name='zpool_vdev_path_to_guid' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_vdev_path_to_guid'>
	+ <parameter type-id='4c81de99' name='zhp'/>
	+ <parameter type-id='80f4b756' name='path'/>
	<return type-id='9c313c2d'/>
	</function-decl>
	- <function-decl name='zfeature_lookup_name' mangled-name='zfeature_lookup_name' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfeature_lookup_name'>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='a8425263'/>
	+ <function-decl name='zpool_vdev_online' mangled-name='zpool_vdev_online' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_vdev_online'>
	+ <parameter type-id='4c81de99' name='zhp'/>
	+ <parameter type-id='80f4b756' name='path'/>
	+ <parameter type-id='95e97e5e' name='flags'/>
	+ <parameter type-id='17f3480d' name='newstate'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zpool_prop_feature' mangled-name='zpool_prop_feature' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_prop_feature'>
	- <parameter type-id='80f4b756'/>
	- <return type-id='c19b74c3'/>
	- </function-decl>
	- <function-decl name='pool_namecheck' mangled-name='pool_namecheck' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='pool_namecheck'>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='053457bd'/>
	- <parameter type-id='26a90f95'/>
	+ <function-decl name='zpool_vdev_offline' mangled-name='zpool_vdev_offline' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_vdev_offline'>
	+ <parameter type-id='4c81de99' name='zhp'/>
	+ <parameter type-id='80f4b756' name='path'/>
	+ <parameter type-id='c19b74c3' name='istmp'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zpool_get_status' mangled-name='zpool_get_status' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_get_status'>
	- <parameter type-id='4c81de99'/>
	- <parameter type-id='9b23c9ad'/>
	- <parameter type-id='cec6f2e4'/>
	- <return type-id='d3dd6294'/>
	- </function-decl>
	- <function-decl name='zpool_prop_get_type' mangled-name='zpool_prop_get_type' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_prop_get_type'>
	- <parameter type-id='5d0c23fb'/>
	- <return type-id='31429eff'/>
	- </function-decl>
	- <function-decl name='zpool_prop_index_to_string' mangled-name='zpool_prop_index_to_string' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_prop_index_to_string'>
	- <parameter type-id='5d0c23fb'/>
	- <parameter type-id='9c313c2d'/>
	- <parameter type-id='7d3cd834'/>
	+ <function-decl name='zpool_vdev_fault' mangled-name='zpool_vdev_fault' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_vdev_fault'>
	+ <parameter type-id='4c81de99' name='zhp'/>
	+ <parameter type-id='9c313c2d' name='guid'/>
	+ <parameter type-id='9d774e0b' name='aux'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zfeature_is_supported' mangled-name='zfeature_is_supported' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfeature_is_supported'>
	- <parameter type-id='80f4b756'/>
	- <return type-id='c19b74c3'/>
	- </function-decl>
	- <function-decl name='strtoull' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='9b23c9ad'/>
	- <parameter type-id='95e97e5e'/>
	- <return type-id='3a47d82b'/>
	- </function-decl>
	- <function-decl name='zfs_strcmp_pathname' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='95e97e5e'/>
	+ <function-decl name='zpool_vdev_degrade' mangled-name='zpool_vdev_degrade' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_vdev_degrade'>
	+ <parameter type-id='4c81de99' name='zhp'/>
	+ <parameter type-id='9c313c2d' name='guid'/>
	+ <parameter type-id='9d774e0b' name='aux'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zpool_standard_error' mangled-name='zpool_standard_error' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_standard_error'>
	- <parameter type-id='b0382bb3'/>
	- <parameter type-id='95e97e5e'/>
	- <parameter type-id='80f4b756'/>
	+ <function-decl name='zpool_vdev_attach' mangled-name='zpool_vdev_attach' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_vdev_attach'>
	+ <parameter type-id='4c81de99' name='zhp'/>
	+ <parameter type-id='80f4b756' name='old_disk'/>
	+ <parameter type-id='80f4b756' name='new_disk'/>
	+ <parameter type-id='5ce45b60' name='nvroot'/>
	+ <parameter type-id='95e97e5e' name='replacing'/>
	+ <parameter type-id='c19b74c3' name='rebuild'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='lzc_pool_checkpoint' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='80f4b756'/>
	+ <function-decl name='zpool_vdev_detach' mangled-name='zpool_vdev_detach' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_vdev_detach'>
	+ <parameter type-id='4c81de99' name='zhp'/>
	+ <parameter type-id='80f4b756' name='path'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='lzc_pool_checkpoint_discard' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='80f4b756'/>
	+ <function-decl name='zpool_vdev_split' mangled-name='zpool_vdev_split' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_vdev_split'>
	+ <parameter type-id='4c81de99' name='zhp'/>
	+ <parameter type-id='26a90f95' name='newname'/>
	+ <parameter type-id='857bb57e' name='newroot'/>
	+ <parameter type-id='5ce45b60' name='props'/>
	+ <parameter type-id='325c1e34' name='flags'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='fnvlist_add_int64' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='5ce45b60'/>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='9da381c4'/>
	- <return type-id='48b5725f'/>
	+ <function-decl name='zpool_vdev_remove' mangled-name='zpool_vdev_remove' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_vdev_remove'>
	+ <parameter type-id='4c81de99' name='zhp'/>
	+ <parameter type-id='80f4b756' name='path'/>
	+ <return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='fnvlist_lookup_uint64' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='5ce45b60'/>
	- <parameter type-id='80f4b756'/>
	- <return type-id='9c313c2d'/>
	+ <function-decl name='zpool_vdev_remove_cancel' mangled-name='zpool_vdev_remove_cancel' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_vdev_remove_cancel'>
	+ <parameter type-id='4c81de99' name='zhp'/>
	+ <return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='lzc_wait_tag' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='73446457'/>
	- <parameter type-id='9c313c2d'/>
	- <parameter type-id='37e3bd22'/>
	+ <function-decl name='zpool_vdev_indirect_size' mangled-name='zpool_vdev_indirect_size' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_vdev_indirect_size'>
	+ <parameter type-id='4c81de99' name='zhp'/>
	+ <parameter type-id='80f4b756' name='path'/>
	+ <parameter type-id='5d6479ae' name='sizep'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='lzc_trim' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='b1146b8d'/>
	- <parameter type-id='9c313c2d'/>
	- <parameter type-id='c19b74c3'/>
	- <parameter type-id='5ce45b60'/>
	- <parameter type-id='857bb57e'/>
	+ <function-decl name='zpool_clear' mangled-name='zpool_clear' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_clear'>
	+ <parameter type-id='4c81de99' name='zhp'/>
	+ <parameter type-id='80f4b756' name='path'/>
	+ <parameter type-id='5ce45b60' name='rewindnvl'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='lzc_initialize' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='7063e1ab'/>
	- <parameter type-id='5ce45b60'/>
	- <parameter type-id='857bb57e'/>
	+ <function-decl name='zpool_vdev_clear' mangled-name='zpool_vdev_clear' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_vdev_clear'>
	+ <parameter type-id='4c81de99' name='zhp'/>
	+ <parameter type-id='9c313c2d' name='guid'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zfs_resolve_shortname' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='26a90f95'/>
	- <parameter type-id='b59d7dce'/>
	+ <function-decl name='zpool_reguid' mangled-name='zpool_reguid' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_reguid'>
	+ <parameter type-id='4c81de99' name='zhp'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zpool_relabel_disk' mangled-name='zpool_relabel_disk' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_relabel_disk'>
	- <parameter type-id='b0382bb3'/>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='80f4b756'/>
	+ <function-decl name='zpool_reopen_one' mangled-name='zpool_reopen_one' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_reopen_one'>
	+ <parameter type-id='4c81de99' name='zhp'/>
	+ <parameter type-id='eaa32e2f' name='data'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zpool_get_load_policy' mangled-name='zpool_get_load_policy' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_get_load_policy'>
	- <parameter type-id='5ce45b60'/>
	- <parameter type-id='23432aaa'/>
	- <return type-id='48b5725f'/>
	+ <function-decl name='zpool_sync_one' mangled-name='zpool_sync_one' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_sync_one'>
	+ <parameter type-id='4c81de99' name='zhp'/>
	+ <parameter type-id='eaa32e2f' name='data'/>
	+ <return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zpool_get_handle' mangled-name='zpool_get_handle' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_get_handle'>
	- <parameter type-id='4c81de99'/>
	- <return type-id='b0382bb3'/>
	+ <function-decl name='zpool_vdev_name' mangled-name='zpool_vdev_name' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_vdev_name'>
	+ <parameter type-id='b0382bb3' name='hdl'/>
	+ <parameter type-id='4c81de99' name='zhp'/>
	+ <parameter type-id='5ce45b60' name='nv'/>
	+ <parameter type-id='95e97e5e' name='name_flags'/>
	+ <return type-id='26a90f95'/>
	</function-decl>
	- <function-decl name='lzc_reopen' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='c19b74c3'/>
	+ <function-decl name='zpool_get_errlog' mangled-name='zpool_get_errlog' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_get_errlog'>
	+ <parameter type-id='4c81de99' name='zhp'/>
	+ <parameter type-id='857bb57e' name='nverrlistp'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='fnvlist_add_boolean_value' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='5ce45b60'/>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='c19b74c3'/>
	+ <function-decl name='zpool_upgrade' mangled-name='zpool_upgrade' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_upgrade'>
	+ <parameter type-id='4c81de99' name='zhp'/>
	+ <parameter type-id='9c313c2d' name='new_version'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='zfs_save_arguments' mangled-name='zfs_save_arguments' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_save_arguments'>
	+ <parameter type-id='95e97e5e' name='argc'/>
	+ <parameter type-id='9b23c9ad' name='argv'/>
	+ <parameter type-id='26a90f95' name='string'/>
	+ <parameter type-id='95e97e5e' name='len'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='lzc_sync' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='5ce45b60'/>
	- <parameter type-id='857bb57e'/>
	+ <function-decl name='zpool_log_history' mangled-name='zpool_log_history' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_log_history'>
	+ <parameter type-id='b0382bb3' name='hdl'/>
	+ <parameter type-id='80f4b756' name='message'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='realpath' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='26a90f95'/>
	- <return type-id='26a90f95'/>
	- </function-decl>
	- <function-decl name='strncasecmp' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='b59d7dce'/>
	+ <function-decl name='zpool_get_history' mangled-name='zpool_get_history' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_get_history'>
	+ <parameter type-id='4c81de99' name='zhp'/>
	+ <parameter type-id='857bb57e' name='nvhisp'/>
	+ <parameter type-id='5d6479ae' name='off'/>
	+ <parameter type-id='37e3bd22' name='eof'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zfs_strip_path' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='26a90f95'/>
	- <return type-id='26a90f95'/>
	+ <function-decl name='zpool_events_next' mangled-name='zpool_events_next' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_events_next'>
	+ <parameter type-id='b0382bb3' name='hdl'/>
	+ <parameter type-id='857bb57e' name='nvp'/>
	+ <parameter type-id='7292109c' name='dropped'/>
	+ <parameter type-id='f0981eeb' name='flags'/>
	+ <parameter type-id='95e97e5e' name='zevent_fd'/>
	+ <return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zfs_strip_partition' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='26a90f95'/>
	- <return type-id='26a90f95'/>
	+ <function-decl name='zpool_events_clear' mangled-name='zpool_events_clear' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_events_clear'>
	+ <parameter type-id='b0382bb3' name='hdl'/>
	+ <parameter type-id='7292109c' name='count'/>
	+ <return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zfeature_lookup_guid' mangled-name='zfeature_lookup_guid' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfeature_lookup_guid'>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='a8425263'/>
	+ <function-decl name='zpool_events_seek' mangled-name='zpool_events_seek' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_events_seek'>
	+ <parameter type-id='b0382bb3' name='hdl'/>
	+ <parameter type-id='9c313c2d' name='eid'/>
	+ <parameter type-id='95e97e5e' name='zevent_fd'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='__xpg_basename' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='26a90f95'/>
	- <return type-id='26a90f95'/>
	+ <function-decl name='zpool_obj_to_path' mangled-name='zpool_obj_to_path' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_obj_to_path'>
	+ <parameter type-id='4c81de99' name='zhp'/>
	+ <parameter type-id='9c313c2d' name='dsobj'/>
	+ <parameter type-id='9c313c2d' name='obj'/>
	+ <parameter type-id='26a90f95' name='pathname'/>
	+ <parameter type-id='b59d7dce' name='len'/>
	+ <return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='zpool_history_unpack' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='26a90f95'/>
	- <parameter type-id='9c313c2d'/>
	- <parameter type-id='5d6479ae'/>
	- <parameter type-id='75be733c'/>
	- <parameter type-id='4dd26a40'/>
	- <return type-id='95e97e5e'/>
	+ <function-decl name='zpool_obj_to_path_ds' mangled-name='zpool_obj_to_path_ds' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_obj_to_path_ds'>
	+ <parameter type-id='4c81de99' name='zhp'/>
	+ <parameter type-id='9c313c2d' name='dsobj'/>
	+ <parameter type-id='9c313c2d' name='obj'/>
	+ <parameter type-id='26a90f95' name='pathname'/>
	+ <parameter type-id='b59d7dce' name='len'/>
	+ <return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='nvlist_add_nvlist_array' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='5ce45b60'/>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='857bb57e'/>
	- <parameter type-id='3502e3ff'/>
	+ <function-decl name='zpool_wait' mangled-name='zpool_wait' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_wait'>
	+ <parameter type-id='4c81de99' name='zhp'/>
	+ <parameter type-id='73446457' name='activity'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='lzc_wait' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='73446457'/>
	- <parameter type-id='37e3bd22'/>
	+ <function-decl name='zpool_wait_status' mangled-name='zpool_wait_status' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_wait_status'>
	+ <parameter type-id='4c81de99' name='zhp'/>
	+ <parameter type-id='73446457' name='activity'/>
	+ <parameter type-id='37e3bd22' name='missing'/>
	+ <parameter type-id='37e3bd22' name='waited'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='lzc_set_bootenv' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='22cce67b'/>
	+ <function-decl name='zpool_set_bootenv' mangled-name='zpool_set_bootenv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_set_bootenv'>
	+ <parameter type-id='4c81de99' name='zhp'/>
	+ <parameter type-id='22cce67b' name='envmap'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='lzc_get_bootenv' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='857bb57e'/>
	+ <function-decl name='zpool_get_bootenv' mangled-name='zpool_get_bootenv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_get_bootenv'>
	+ <parameter type-id='4c81de99' name='zhp'/>
	+ <parameter type-id='857bb57e' name='nvlp'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='__strtok_r' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='zpool_load_compat' mangled-name='zpool_load_compat' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_load_compat'>
	+ <parameter type-id='80f4b756' name='compat'/>
	+ <parameter type-id='37e3bd22' name='features'/>
	+ <parameter type-id='26a90f95' name='report'/>
	+ <parameter type-id='b59d7dce' name='rlen'/>
	+ <return type-id='901b78d1'/>
	+ </function-decl>
	+ <function-decl name='__xpg_basename' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='26a90f95'/>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='9b23c9ad'/>
	<return type-id='26a90f95'/>
	</function-decl>
	- <function-decl name='munmap' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='strtoull' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='9d26089a'/>
	+ <parameter type-id='8c85230f'/>
	+ <parameter type-id='95e97e5e'/>
	+ <return type-id='3a47d82b'/>
	+ </function-decl>
	+ <function-decl name='realpath' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='9d26089a'/>
	+ <parameter type-id='266fe297'/>
	+ <return type-id='26a90f95'/>
	+ </function-decl>
	+ <function-decl name='memcmp' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='eaa32e2f'/>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='b59d7dce'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='__xstat64' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='95e97e5e'/>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='62f7a03d'/>
	- <return type-id='95e97e5e'/>
	+ <function-decl name='strtok_r' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='266fe297'/>
	+ <parameter type-id='9d26089a'/>
	+ <parameter type-id='8c85230f'/>
	+ <return type-id='26a90f95'/>
	</function-decl>
	- <function-decl name='zpool_name_to_prop' mangled-name='zpool_name_to_prop' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_name_to_prop'>
	+ <function-decl name='strncasecmp' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='80f4b756'/>
	- <return type-id='5d0c23fb'/>
	- </function-decl>
	- <function-decl name='zpool_prop_readonly' mangled-name='zpool_prop_readonly' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_prop_readonly'>
	- <parameter type-id='5d0c23fb'/>
	- <return type-id='c19b74c3'/>
	- </function-decl>
	- <function-decl name='zpool_prop_setonce' mangled-name='zpool_prop_setonce' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_prop_setonce'>
	- <parameter type-id='5d0c23fb'/>
	- <return type-id='c19b74c3'/>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='b59d7dce'/>
	+ <return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='get_system_hostid' visibility='default' binding='global' size-in-bits='64'>
	- <return type-id='7359adad'/>
	+ <function-decl name='munmap' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='eaa32e2f'/>
	+ <parameter type-id='b59d7dce'/>
	+ <return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='nvlist_add_uint8_array' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='5ce45b60'/>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='ae3e8ca6'/>
	- <parameter type-id='3502e3ff'/>
	+ <function-decl name='stat64' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='9d26089a'/>
	+ <parameter type-id='f1cadedf'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	</abi-instr>
	- <abi-instr version='1.0' address-size='64' path='libzfs_sendrecv.c' language='LANG_C89'>
	+ <abi-instr address-size='64' path='libzfs_sendrecv.c' language='LANG_C99'>
	<array-type-def dimensions='1' type-id='9c313c2d' size-in-bits='2176' id='8c2bcad1'>
	- <subrange length='34' type-id='4c87fef4' id='6a6a7e00'/>
	+ <subrange length='34' type-id='7359adad' id='6a6a7e00'/>
	</array-type-def>
	<array-type-def dimensions='1' type-id='9c313c2d' size-in-bits='256' id='85c64d26'>
	- <subrange length='4' type-id='4c87fef4' id='16fe7105'/>
	+ <subrange length='4' type-id='7359adad' id='16fe7105'/>
	</array-type-def>
	<array-type-def dimensions='1' type-id='b96825af' size-in-bits='96' id='fa8ef949'>
	- <subrange length='12' type-id='4c87fef4' id='84827bdc'/>
	+ <subrange length='12' type-id='7359adad' id='84827bdc'/>
	</array-type-def>
	<array-type-def dimensions='1' type-id='b96825af' size-in-bits='128' id='fa9986a5'>
	- <subrange length='16' type-id='4c87fef4' id='848d0938'/>
	+ <subrange length='16' type-id='7359adad' id='848d0938'/>
	</array-type-def>
	<array-type-def dimensions='1' type-id='b96825af' size-in-bits='40' id='0f4ddd0b'>
	- <subrange length='5' type-id='4c87fef4' id='53010e10'/>
	+ <subrange length='5' type-id='7359adad' id='53010e10'/>
	</array-type-def>
	<array-type-def dimensions='1' type-id='b96825af' size-in-bits='48' id='0f562bd0'>
	- <subrange length='6' type-id='4c87fef4' id='52fa524b'/>
	+ <subrange length='6' type-id='7359adad' id='52fa524b'/>
	</array-type-def>
	<array-type-def dimensions='1' type-id='b96825af' size-in-bits='64' id='13339fda'>
	- <subrange length='8' type-id='4c87fef4' id='56e0c0b1'/>
	+ <subrange length='8' type-id='7359adad' id='56e0c0b1'/>
	</array-type-def>
	- <typedef-decl name='sendflags_t' type-id='f6aa15be' id='945467e6'/>
	<class-decl name='sendflags' size-in-bits='544' is-struct='yes' visibility='default' id='f6aa15be'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='verbosity' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='32'>
	<var-decl name='replicate' type-id='c19b74c3' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='skipmissing' type-id='c19b74c3' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='96'>
	<var-decl name='doall' type-id='c19b74c3' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='fromorigin' type-id='c19b74c3' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='160'>
	<var-decl name='pad' type-id='c19b74c3' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	<var-decl name='props' type-id='c19b74c3' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='224'>
	<var-decl name='dryrun' type-id='c19b74c3' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='256'>
	<var-decl name='parsable' type-id='c19b74c3' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='288'>
	<var-decl name='progress' type-id='c19b74c3' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='320'>
	<var-decl name='largeblock' type-id='c19b74c3' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='352'>
	<var-decl name='embed_data' type-id='c19b74c3' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='384'>
	<var-decl name='compress' type-id='c19b74c3' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='416'>
	<var-decl name='raw' type-id='c19b74c3' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='448'>
	<var-decl name='backup' type-id='c19b74c3' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='480'>
	<var-decl name='holds' type-id='c19b74c3' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='512'>
	<var-decl name='saved' type-id='c19b74c3' visibility='default'/>
	</data-member>
	</class-decl>
	+ <typedef-decl name='sendflags_t' type-id='f6aa15be' id='945467e6'/>
	<typedef-decl name='snapfilter_cb_t' type-id='d2a5e211' id='3d3ffb69'/>
	- <typedef-decl name='recvflags_t' type-id='34a384dc' id='9e59d1d4'/>
	<class-decl name='recvflags' size-in-bits='416' is-struct='yes' visibility='default' id='34a384dc'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='verbose' type-id='c19b74c3' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='32'>
	<var-decl name='isprefix' type-id='c19b74c3' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='istail' type-id='c19b74c3' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='96'>
	<var-decl name='dryrun' type-id='c19b74c3' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='force' type-id='c19b74c3' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='160'>
	<var-decl name='canmountoff' type-id='c19b74c3' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	<var-decl name='resumable' type-id='c19b74c3' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='224'>
	<var-decl name='byteswap' type-id='c19b74c3' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='256'>
	<var-decl name='nomount' type-id='c19b74c3' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='288'>
	<var-decl name='holds' type-id='c19b74c3' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='320'>
	<var-decl name='skipholds' type-id='c19b74c3' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='352'>
	<var-decl name='domount' type-id='c19b74c3' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='384'>
	<var-decl name='forceunmount' type-id='c19b74c3' visibility='default'/>
	</data-member>
	</class-decl>
	+ <typedef-decl name='recvflags_t' type-id='34a384dc' id='9e59d1d4'/>
	<enum-decl name='lzc_send_flags' id='bfbd3c8e'>
	<underlying-type type-id='9cac1fee'/>
	<enumerator name='LZC_SEND_FLAG_EMBED_DATA' value='1'/>
	<enumerator name='LZC_SEND_FLAG_LARGE_BLOCK' value='2'/>
	<enumerator name='LZC_SEND_FLAG_COMPRESS' value='4'/>
	<enumerator name='LZC_SEND_FLAG_RAW' value='8'/>
	<enumerator name='LZC_SEND_FLAG_SAVED' value='16'/>
	</enum-decl>
	+ <class-decl name='ddt_key' size-in-bits='320' is-struct='yes' visibility='default' id='e0a4a1cb'>
	+ <data-member access='public' layout-offset-in-bits='0'>
	+ <var-decl name='ddk_cksum' type-id='39730d0b' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='256'>
	+ <var-decl name='ddk_prop' type-id='9c313c2d' visibility='default'/>
	+ </data-member>
	+ </class-decl>
	+ <typedef-decl name='ddt_key_t' type-id='e0a4a1cb' id='67f6d2cf'/>
	+ <enum-decl name='dmu_object_type' id='04b3b0b9'>
	+ <underlying-type type-id='9cac1fee'/>
	+ <enumerator name='DMU_OT_NONE' value='0'/>
	+ <enumerator name='DMU_OT_OBJECT_DIRECTORY' value='1'/>
	+ <enumerator name='DMU_OT_OBJECT_ARRAY' value='2'/>
	+ <enumerator name='DMU_OT_PACKED_NVLIST' value='3'/>
	+ <enumerator name='DMU_OT_PACKED_NVLIST_SIZE' value='4'/>
	+ <enumerator name='DMU_OT_BPOBJ' value='5'/>
	+ <enumerator name='DMU_OT_BPOBJ_HDR' value='6'/>
	+ <enumerator name='DMU_OT_SPACE_MAP_HEADER' value='7'/>
	+ <enumerator name='DMU_OT_SPACE_MAP' value='8'/>
	+ <enumerator name='DMU_OT_INTENT_LOG' value='9'/>
	+ <enumerator name='DMU_OT_DNODE' value='10'/>
	+ <enumerator name='DMU_OT_OBJSET' value='11'/>
	+ <enumerator name='DMU_OT_DSL_DIR' value='12'/>
	+ <enumerator name='DMU_OT_DSL_DIR_CHILD_MAP' value='13'/>
	+ <enumerator name='DMU_OT_DSL_DS_SNAP_MAP' value='14'/>
	+ <enumerator name='DMU_OT_DSL_PROPS' value='15'/>
	+ <enumerator name='DMU_OT_DSL_DATASET' value='16'/>
	+ <enumerator name='DMU_OT_ZNODE' value='17'/>
	+ <enumerator name='DMU_OT_OLDACL' value='18'/>
	+ <enumerator name='DMU_OT_PLAIN_FILE_CONTENTS' value='19'/>
	+ <enumerator name='DMU_OT_DIRECTORY_CONTENTS' value='20'/>
	+ <enumerator name='DMU_OT_MASTER_NODE' value='21'/>
	+ <enumerator name='DMU_OT_UNLINKED_SET' value='22'/>
	+ <enumerator name='DMU_OT_ZVOL' value='23'/>
	+ <enumerator name='DMU_OT_ZVOL_PROP' value='24'/>
	+ <enumerator name='DMU_OT_PLAIN_OTHER' value='25'/>
	+ <enumerator name='DMU_OT_UINT64_OTHER' value='26'/>
	+ <enumerator name='DMU_OT_ZAP_OTHER' value='27'/>
	+ <enumerator name='DMU_OT_ERROR_LOG' value='28'/>
	+ <enumerator name='DMU_OT_SPA_HISTORY' value='29'/>
	+ <enumerator name='DMU_OT_SPA_HISTORY_OFFSETS' value='30'/>
	+ <enumerator name='DMU_OT_POOL_PROPS' value='31'/>
	+ <enumerator name='DMU_OT_DSL_PERMS' value='32'/>
	+ <enumerator name='DMU_OT_ACL' value='33'/>
	+ <enumerator name='DMU_OT_SYSACL' value='34'/>
	+ <enumerator name='DMU_OT_FUID' value='35'/>
	+ <enumerator name='DMU_OT_FUID_SIZE' value='36'/>
	+ <enumerator name='DMU_OT_NEXT_CLONES' value='37'/>
	+ <enumerator name='DMU_OT_SCAN_QUEUE' value='38'/>
	+ <enumerator name='DMU_OT_USERGROUP_USED' value='39'/>
	+ <enumerator name='DMU_OT_USERGROUP_QUOTA' value='40'/>
	+ <enumerator name='DMU_OT_USERREFS' value='41'/>
	+ <enumerator name='DMU_OT_DDT_ZAP' value='42'/>
	+ <enumerator name='DMU_OT_DDT_STATS' value='43'/>
	+ <enumerator name='DMU_OT_SA' value='44'/>
	+ <enumerator name='DMU_OT_SA_MASTER_NODE' value='45'/>
	+ <enumerator name='DMU_OT_SA_ATTR_REGISTRATION' value='46'/>
	+ <enumerator name='DMU_OT_SA_ATTR_LAYOUTS' value='47'/>
	+ <enumerator name='DMU_OT_SCAN_XLATE' value='48'/>
	+ <enumerator name='DMU_OT_DEDUP' value='49'/>
	+ <enumerator name='DMU_OT_DEADLIST' value='50'/>
	+ <enumerator name='DMU_OT_DEADLIST_HDR' value='51'/>
	+ <enumerator name='DMU_OT_DSL_CLONES' value='52'/>
	+ <enumerator name='DMU_OT_BPOBJ_SUBOBJ' value='53'/>
	+ <enumerator name='DMU_OT_NUMTYPES' value='54'/>
	+ <enumerator name='DMU_OTN_UINT8_DATA' value='128'/>
	+ <enumerator name='DMU_OTN_UINT8_METADATA' value='192'/>
	+ <enumerator name='DMU_OTN_UINT16_DATA' value='129'/>
	+ <enumerator name='DMU_OTN_UINT16_METADATA' value='193'/>
	+ <enumerator name='DMU_OTN_UINT32_DATA' value='130'/>
	+ <enumerator name='DMU_OTN_UINT32_METADATA' value='194'/>
	+ <enumerator name='DMU_OTN_UINT64_DATA' value='131'/>
	+ <enumerator name='DMU_OTN_UINT64_METADATA' value='195'/>
	+ <enumerator name='DMU_OTN_ZAP_DATA' value='132'/>
	+ <enumerator name='DMU_OTN_ZAP_METADATA' value='196'/>
	+ <enumerator name='DMU_OTN_UINT8_ENC_DATA' value='160'/>
	+ <enumerator name='DMU_OTN_UINT8_ENC_METADATA' value='224'/>
	+ <enumerator name='DMU_OTN_UINT16_ENC_DATA' value='161'/>
	+ <enumerator name='DMU_OTN_UINT16_ENC_METADATA' value='225'/>
	+ <enumerator name='DMU_OTN_UINT32_ENC_DATA' value='162'/>
	+ <enumerator name='DMU_OTN_UINT32_ENC_METADATA' value='226'/>
	+ <enumerator name='DMU_OTN_UINT64_ENC_DATA' value='163'/>
	+ <enumerator name='DMU_OTN_UINT64_ENC_METADATA' value='227'/>
	+ <enumerator name='DMU_OTN_ZAP_ENC_DATA' value='164'/>
	+ <enumerator name='DMU_OTN_ZAP_ENC_METADATA' value='228'/>
	+ </enum-decl>
	+ <typedef-decl name='dmu_object_type_t' type-id='04b3b0b9' id='5c9d8906'/>
	+ <class-decl name='zio_cksum' size-in-bits='256' is-struct='yes' visibility='default' id='1d53e28b'>
	+ <data-member access='public' layout-offset-in-bits='0'>
	+ <var-decl name='zc_word' type-id='85c64d26' visibility='default'/>
	+ </data-member>
	+ </class-decl>
	+ <typedef-decl name='zio_cksum_t' type-id='1d53e28b' id='39730d0b'/>
	<class-decl name='dmu_replay_record' size-in-bits='2496' is-struct='yes' visibility='default' id='781a52d7'>
	<data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='drr_type' type-id='08f5ca1f' visibility='default'/>
	+ <var-decl name='drr_type' type-id='08f5ca17' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='32'>
	<var-decl name='drr_payloadlen' type-id='8f92235e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='drr_u' type-id='edc8c94a' visibility='default'/>
	+ <var-decl name='drr_u' type-id='ac5ab59b' visibility='default'/>
	</data-member>
	</class-decl>
	- <enum-decl name='__anonymous_enum__' is-anonymous='yes' id='08f5ca1f'>
	+ <enum-decl name='__anonymous_enum__' is-anonymous='yes' id='08f5ca17'>
	<underlying-type type-id='9cac1fee'/>
	<enumerator name='DRR_BEGIN' value='0'/>
	<enumerator name='DRR_OBJECT' value='1'/>
	<enumerator name='DRR_FREEOBJECTS' value='2'/>
	<enumerator name='DRR_WRITE' value='3'/>
	<enumerator name='DRR_FREE' value='4'/>
	<enumerator name='DRR_END' value='5'/>
	<enumerator name='DRR_WRITE_BYREF' value='6'/>
	<enumerator name='DRR_SPILL' value='7'/>
	<enumerator name='DRR_WRITE_EMBEDDED' value='8'/>
	<enumerator name='DRR_OBJECT_RANGE' value='9'/>
	<enumerator name='DRR_REDACT' value='10'/>
	<enumerator name='DRR_NUMTYPES' value='11'/>
	</enum-decl>
	- <union-decl name='__anonymous_union__' size-in-bits='2432' is-anonymous='yes' visibility='default' id='edc8c94a'>
	- <data-member access='private'>
	+ <union-decl name='__anonymous_union__' size-in-bits='2432' is-anonymous='yes' visibility='default' id='ac5ab59b'>
	+ <data-member access='public'>
	<var-decl name='drr_begin' type-id='09fcdc01' visibility='default'/>
	</data-member>
	- <data-member access='private'>
	+ <data-member access='public'>
	<var-decl name='drr_end' type-id='6ee25631' visibility='default'/>
	</data-member>
	- <data-member access='private'>
	+ <data-member access='public'>
	<var-decl name='drr_object' type-id='f9ad530b' visibility='default'/>
	</data-member>
	- <data-member access='private'>
	+ <data-member access='public'>
	<var-decl name='drr_freeobjects' type-id='a27d958e' visibility='default'/>
	</data-member>
	- <data-member access='private'>
	+ <data-member access='public'>
	<var-decl name='drr_write' type-id='4cc69e4b' visibility='default'/>
	</data-member>
	- <data-member access='private'>
	+ <data-member access='public'>
	<var-decl name='drr_free' type-id='c836cfd2' visibility='default'/>
	</data-member>
	- <data-member access='private'>
	+ <data-member access='public'>
	<var-decl name='drr_write_byref' type-id='e511cdce' visibility='default'/>
	</data-member>
	- <data-member access='private'>
	+ <data-member access='public'>
	<var-decl name='drr_spill' type-id='1e69a80a' visibility='default'/>
	</data-member>
	- <data-member access='private'>
	+ <data-member access='public'>
	<var-decl name='drr_write_embedded' type-id='98b1345e' visibility='default'/>
	</data-member>
	- <data-member access='private'>
	+ <data-member access='public'>
	<var-decl name='drr_object_range' type-id='aba1f9e1' visibility='default'/>
	</data-member>
	- <data-member access='private'>
	+ <data-member access='public'>
	<var-decl name='drr_redact' type-id='50389039' visibility='default'/>
	</data-member>
	- <data-member access='private'>
	+ <data-member access='public'>
	<var-decl name='drr_checksum' type-id='a5fe3647' visibility='default'/>
	</data-member>
	</union-decl>
	<class-decl name='drr_end' size-in-bits='320' is-struct='yes' visibility='default' id='6ee25631'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='drr_checksum' type-id='39730d0b' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='256'>
	<var-decl name='drr_toguid' type-id='9c313c2d' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='zio_cksum_t' type-id='1d53e28b' id='39730d0b'/>
	- <class-decl name='zio_cksum' size-in-bits='256' is-struct='yes' visibility='default' id='1d53e28b'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='zc_word' type-id='85c64d26' visibility='default'/>
	- </data-member>
	- </class-decl>
	<class-decl name='drr_object' size-in-bits='448' is-struct='yes' visibility='default' id='f9ad530b'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='drr_object' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='drr_type' type-id='5c9d8906' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='96'>
	<var-decl name='drr_bonustype' type-id='5c9d8906' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='drr_blksz' type-id='8f92235e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='160'>
	<var-decl name='drr_bonuslen' type-id='8f92235e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	<var-decl name='drr_checksumtype' type-id='b96825af' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='200'>
	<var-decl name='drr_compress' type-id='b96825af' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='208'>
	<var-decl name='drr_dn_slots' type-id='b96825af' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='216'>
	<var-decl name='drr_flags' type-id='b96825af' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='224'>
	<var-decl name='drr_raw_bonuslen' type-id='8f92235e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='256'>
	<var-decl name='drr_toguid' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='320'>
	<var-decl name='drr_indblkshift' type-id='b96825af' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='328'>
	<var-decl name='drr_nlevels' type-id='b96825af' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='336'>
	<var-decl name='drr_nblkptr' type-id='b96825af' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='344'>
	<var-decl name='drr_pad' type-id='0f4ddd0b' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='384'>
	<var-decl name='drr_maxblkid' type-id='9c313c2d' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='dmu_object_type_t' type-id='04b3b0b9' id='5c9d8906'/>
	- <enum-decl name='dmu_object_type' id='04b3b0b9'>
	- <underlying-type type-id='9cac1fee'/>
	- <enumerator name='DMU_OT_NONE' value='0'/>
	- <enumerator name='DMU_OT_OBJECT_DIRECTORY' value='1'/>
	- <enumerator name='DMU_OT_OBJECT_ARRAY' value='2'/>
	- <enumerator name='DMU_OT_PACKED_NVLIST' value='3'/>
	- <enumerator name='DMU_OT_PACKED_NVLIST_SIZE' value='4'/>
	- <enumerator name='DMU_OT_BPOBJ' value='5'/>
	- <enumerator name='DMU_OT_BPOBJ_HDR' value='6'/>
	- <enumerator name='DMU_OT_SPACE_MAP_HEADER' value='7'/>
	- <enumerator name='DMU_OT_SPACE_MAP' value='8'/>
	- <enumerator name='DMU_OT_INTENT_LOG' value='9'/>
	- <enumerator name='DMU_OT_DNODE' value='10'/>
	- <enumerator name='DMU_OT_OBJSET' value='11'/>
	- <enumerator name='DMU_OT_DSL_DIR' value='12'/>
	- <enumerator name='DMU_OT_DSL_DIR_CHILD_MAP' value='13'/>
	- <enumerator name='DMU_OT_DSL_DS_SNAP_MAP' value='14'/>
	- <enumerator name='DMU_OT_DSL_PROPS' value='15'/>
	- <enumerator name='DMU_OT_DSL_DATASET' value='16'/>
	- <enumerator name='DMU_OT_ZNODE' value='17'/>
	- <enumerator name='DMU_OT_OLDACL' value='18'/>
	- <enumerator name='DMU_OT_PLAIN_FILE_CONTENTS' value='19'/>
	- <enumerator name='DMU_OT_DIRECTORY_CONTENTS' value='20'/>
	- <enumerator name='DMU_OT_MASTER_NODE' value='21'/>
	- <enumerator name='DMU_OT_UNLINKED_SET' value='22'/>
	- <enumerator name='DMU_OT_ZVOL' value='23'/>
	- <enumerator name='DMU_OT_ZVOL_PROP' value='24'/>
	- <enumerator name='DMU_OT_PLAIN_OTHER' value='25'/>
	- <enumerator name='DMU_OT_UINT64_OTHER' value='26'/>
	- <enumerator name='DMU_OT_ZAP_OTHER' value='27'/>
	- <enumerator name='DMU_OT_ERROR_LOG' value='28'/>
	- <enumerator name='DMU_OT_SPA_HISTORY' value='29'/>
	- <enumerator name='DMU_OT_SPA_HISTORY_OFFSETS' value='30'/>
	- <enumerator name='DMU_OT_POOL_PROPS' value='31'/>
	- <enumerator name='DMU_OT_DSL_PERMS' value='32'/>
	- <enumerator name='DMU_OT_ACL' value='33'/>
	- <enumerator name='DMU_OT_SYSACL' value='34'/>
	- <enumerator name='DMU_OT_FUID' value='35'/>
	- <enumerator name='DMU_OT_FUID_SIZE' value='36'/>
	- <enumerator name='DMU_OT_NEXT_CLONES' value='37'/>
	- <enumerator name='DMU_OT_SCAN_QUEUE' value='38'/>
	- <enumerator name='DMU_OT_USERGROUP_USED' value='39'/>
	- <enumerator name='DMU_OT_USERGROUP_QUOTA' value='40'/>
	- <enumerator name='DMU_OT_USERREFS' value='41'/>
	- <enumerator name='DMU_OT_DDT_ZAP' value='42'/>
	- <enumerator name='DMU_OT_DDT_STATS' value='43'/>
	- <enumerator name='DMU_OT_SA' value='44'/>
	- <enumerator name='DMU_OT_SA_MASTER_NODE' value='45'/>
	- <enumerator name='DMU_OT_SA_ATTR_REGISTRATION' value='46'/>
	- <enumerator name='DMU_OT_SA_ATTR_LAYOUTS' value='47'/>
	- <enumerator name='DMU_OT_SCAN_XLATE' value='48'/>
	- <enumerator name='DMU_OT_DEDUP' value='49'/>
	- <enumerator name='DMU_OT_DEADLIST' value='50'/>
	- <enumerator name='DMU_OT_DEADLIST_HDR' value='51'/>
	- <enumerator name='DMU_OT_DSL_CLONES' value='52'/>
	- <enumerator name='DMU_OT_BPOBJ_SUBOBJ' value='53'/>
	- <enumerator name='DMU_OT_NUMTYPES' value='54'/>
	- <enumerator name='DMU_OTN_UINT8_DATA' value='128'/>
	- <enumerator name='DMU_OTN_UINT8_METADATA' value='192'/>
	- <enumerator name='DMU_OTN_UINT16_DATA' value='129'/>
	- <enumerator name='DMU_OTN_UINT16_METADATA' value='193'/>
	- <enumerator name='DMU_OTN_UINT32_DATA' value='130'/>
	- <enumerator name='DMU_OTN_UINT32_METADATA' value='194'/>
	- <enumerator name='DMU_OTN_UINT64_DATA' value='131'/>
	- <enumerator name='DMU_OTN_UINT64_METADATA' value='195'/>
	- <enumerator name='DMU_OTN_ZAP_DATA' value='132'/>
	- <enumerator name='DMU_OTN_ZAP_METADATA' value='196'/>
	- <enumerator name='DMU_OTN_UINT8_ENC_DATA' value='160'/>
	- <enumerator name='DMU_OTN_UINT8_ENC_METADATA' value='224'/>
	- <enumerator name='DMU_OTN_UINT16_ENC_DATA' value='161'/>
	- <enumerator name='DMU_OTN_UINT16_ENC_METADATA' value='225'/>
	- <enumerator name='DMU_OTN_UINT32_ENC_DATA' value='162'/>
	- <enumerator name='DMU_OTN_UINT32_ENC_METADATA' value='226'/>
	- <enumerator name='DMU_OTN_UINT64_ENC_DATA' value='163'/>
	- <enumerator name='DMU_OTN_UINT64_ENC_METADATA' value='227'/>
	- <enumerator name='DMU_OTN_ZAP_ENC_DATA' value='164'/>
	- <enumerator name='DMU_OTN_ZAP_ENC_METADATA' value='228'/>
	- </enum-decl>
	<class-decl name='drr_freeobjects' size-in-bits='192' is-struct='yes' visibility='default' id='a27d958e'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='drr_firstobj' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='drr_numobjs' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='drr_toguid' type-id='9c313c2d' visibility='default'/>
	</data-member>
	</class-decl>
	<class-decl name='drr_write' size-in-bits='1088' is-struct='yes' visibility='default' id='4cc69e4b'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='drr_object' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='drr_type' type-id='5c9d8906' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='96'>
	<var-decl name='drr_pad' type-id='8f92235e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='drr_offset' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	<var-decl name='drr_logical_size' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='256'>
	<var-decl name='drr_toguid' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='320'>
	<var-decl name='drr_checksumtype' type-id='b96825af' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='328'>
	<var-decl name='drr_flags' type-id='b96825af' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='336'>
	<var-decl name='drr_compressiontype' type-id='b96825af' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='344'>
	<var-decl name='drr_pad2' type-id='0f4ddd0b' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='384'>
	<var-decl name='drr_key' type-id='67f6d2cf' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='704'>
	<var-decl name='drr_compressed_size' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='768'>
	<var-decl name='drr_salt' type-id='13339fda' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='832'>
	<var-decl name='drr_iv' type-id='fa8ef949' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='928'>
	<var-decl name='drr_mac' type-id='fa9986a5' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='ddt_key_t' type-id='e0a4a1cb' id='67f6d2cf'/>
	- <class-decl name='ddt_key' size-in-bits='320' is-struct='yes' visibility='default' id='e0a4a1cb'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='ddk_cksum' type-id='39730d0b' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='256'>
	- <var-decl name='ddk_prop' type-id='9c313c2d' visibility='default'/>
	- </data-member>
	- </class-decl>
	<class-decl name='drr_free' size-in-bits='256' is-struct='yes' visibility='default' id='c836cfd2'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='drr_object' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='drr_offset' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='drr_length' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	<var-decl name='drr_toguid' type-id='9c313c2d' visibility='default'/>
	</data-member>
	</class-decl>
	<class-decl name='drr_write_byref' size-in-bits='832' is-struct='yes' visibility='default' id='e511cdce'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='drr_object' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='drr_offset' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='drr_length' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	<var-decl name='drr_toguid' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='256'>
	<var-decl name='drr_refguid' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='320'>
	<var-decl name='drr_refobject' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='384'>
	<var-decl name='drr_refoffset' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='448'>
	<var-decl name='drr_checksumtype' type-id='b96825af' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='456'>
	<var-decl name='drr_flags' type-id='b96825af' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='464'>
	<var-decl name='drr_pad2' type-id='0f562bd0' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='512'>
	<var-decl name='drr_key' type-id='67f6d2cf' visibility='default'/>
	</data-member>
	</class-decl>
	<class-decl name='drr_spill' size-in-bits='640' is-struct='yes' visibility='default' id='1e69a80a'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='drr_object' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='drr_length' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='drr_toguid' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	<var-decl name='drr_flags' type-id='b96825af' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='200'>
	<var-decl name='drr_compressiontype' type-id='b96825af' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='208'>
	<var-decl name='drr_pad' type-id='0f562bd0' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='256'>
	<var-decl name='drr_compressed_size' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='320'>
	<var-decl name='drr_salt' type-id='13339fda' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='384'>
	<var-decl name='drr_iv' type-id='fa8ef949' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='480'>
	<var-decl name='drr_mac' type-id='fa9986a5' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='608'>
	<var-decl name='drr_type' type-id='5c9d8906' visibility='default'/>
	</data-member>
	</class-decl>
	<class-decl name='drr_write_embedded' size-in-bits='384' is-struct='yes' visibility='default' id='98b1345e'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='drr_object' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='drr_offset' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='drr_length' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	<var-decl name='drr_toguid' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='256'>
	<var-decl name='drr_compression' type-id='b96825af' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='264'>
	<var-decl name='drr_etype' type-id='b96825af' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='272'>
	<var-decl name='drr_pad' type-id='0f562bd0' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='320'>
	<var-decl name='drr_lsize' type-id='8f92235e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='352'>
	<var-decl name='drr_psize' type-id='8f92235e' visibility='default'/>
	</data-member>
	</class-decl>
	<class-decl name='drr_object_range' size-in-bits='512' is-struct='yes' visibility='default' id='aba1f9e1'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='drr_firstobj' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='drr_numslots' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='drr_toguid' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	<var-decl name='drr_salt' type-id='13339fda' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='256'>
	<var-decl name='drr_iv' type-id='fa8ef949' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='352'>
	<var-decl name='drr_mac' type-id='fa9986a5' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='480'>
	<var-decl name='drr_flags' type-id='b96825af' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='488'>
	<var-decl name='drr_pad' type-id='d3490169' visibility='default'/>
	</data-member>
	</class-decl>
	<class-decl name='drr_redact' size-in-bits='256' is-struct='yes' visibility='default' id='50389039'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='drr_object' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='drr_offset' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='drr_length' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	<var-decl name='drr_toguid' type-id='9c313c2d' visibility='default'/>
	</data-member>
	</class-decl>
	<class-decl name='drr_checksum' size-in-bits='2432' is-struct='yes' visibility='default' id='a5fe3647'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='drr_pad' type-id='8c2bcad1' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='2176'>
	<var-decl name='drr_checksum' type-id='39730d0b' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='Bytef' type-id='efb9ba06' id='c1606520'/>
	<typedef-decl name='Byte' type-id='002ac4a6' id='efb9ba06'/>
	- <typedef-decl name='uLongf' type-id='5bbcce85' id='4d39af59'/>
	<typedef-decl name='uLong' type-id='7359adad' id='5bbcce85'/>
	+ <typedef-decl name='Bytef' type-id='efb9ba06' id='c1606520'/>
	+ <typedef-decl name='uLongf' type-id='5bbcce85' id='4d39af59'/>
	<pointer-type-def type-id='c1606520' size-in-bits='64' id='4c667223'/>
	<qualified-type-def type-id='c1606520' const='yes' id='a6124a50'/>
	<pointer-type-def type-id='a6124a50' size-in-bits='64' id='e8cb3e0e'/>
	<qualified-type-def type-id='781a52d7' const='yes' id='413ab2b8'/>
	<pointer-type-def type-id='413ab2b8' size-in-bits='64' id='41671bd6'/>
	<pointer-type-def type-id='3ff5601b' size-in-bits='64' id='4aafb922'/>
	<pointer-type-def type-id='9e59d1d4' size-in-bits='64' id='4ea84b4f'/>
	<pointer-type-def type-id='945467e6' size-in-bits='64' id='8def7735'/>
	<pointer-type-def type-id='3d3ffb69' size-in-bits='64' id='72a26210'/>
	<pointer-type-def type-id='c9d12d66' size-in-bits='64' id='b2eb2c3f'/>
	<pointer-type-def type-id='4d39af59' size-in-bits='64' id='60db3356'/>
	<pointer-type-def type-id='39730d0b' size-in-bits='64' id='c24fc2ee'/>
	+ <function-decl name='nvlist_print' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='822cd80b'/>
	+ <parameter type-id='5ce45b60'/>
	+ <return type-id='48b5725f'/>
	+ </function-decl>
	+ <function-decl name='zfs_get_pool_handle' mangled-name='zfs_get_pool_handle' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_get_pool_handle'>
	+ <parameter type-id='fcd57163'/>
	+ <return type-id='4c81de99'/>
	+ </function-decl>
	+ <function-decl name='lzc_send_redacted' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='95e97e5e'/>
	+ <parameter type-id='bfbd3c8e'/>
	+ <parameter type-id='80f4b756'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='lzc_send_resume_redacted' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='95e97e5e'/>
	+ <parameter type-id='bfbd3c8e'/>
	+ <parameter type-id='9c313c2d'/>
	+ <parameter type-id='9c313c2d'/>
	+ <parameter type-id='80f4b756'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='lzc_receive_with_cmdprops' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='5ce45b60'/>
	+ <parameter type-id='5ce45b60'/>
	+ <parameter type-id='ae3e8ca6'/>
	+ <parameter type-id='3502e3ff'/>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='c19b74c3'/>
	+ <parameter type-id='c19b74c3'/>
	+ <parameter type-id='c19b74c3'/>
	+ <parameter type-id='95e97e5e'/>
	+ <parameter type-id='41671bd6'/>
	+ <parameter type-id='95e97e5e'/>
	+ <parameter type-id='5d6479ae'/>
	+ <parameter type-id='5d6479ae'/>
	+ <parameter type-id='5d6479ae'/>
	+ <parameter type-id='857bb57e'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='lzc_send_space' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='bfbd3c8e'/>
	+ <parameter type-id='5d6479ae'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='lzc_send_space_resume_redacted' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='bfbd3c8e'/>
	+ <parameter type-id='9c313c2d'/>
	+ <parameter type-id='9c313c2d'/>
	+ <parameter type-id='9c313c2d'/>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='95e97e5e'/>
	+ <parameter type-id='5d6479ae'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='lzc_rename' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='80f4b756'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='libzfs_set_pipe_max' mangled-name='libzfs_set_pipe_max' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libzfs_set_pipe_max'>
	+ <parameter type-id='95e97e5e'/>
	+ <return type-id='48b5725f'/>
	+ </function-decl>
	+ <function-decl name='nvlist_lookup_boolean' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='5ce45b60'/>
	+ <parameter type-id='80f4b756'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='nvpair_value_int32' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='3fa542f0'/>
	+ <parameter type-id='4aafb922'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='fnvlist_size' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='5ce45b60'/>
	+ <return type-id='b59d7dce'/>
	+ </function-decl>
	+ <function-decl name='fnvlist_merge' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='5ce45b60'/>
	+ <parameter type-id='5ce45b60'/>
	+ <return type-id='48b5725f'/>
	+ </function-decl>
	+ <function-decl name='fnvlist_add_nvpair' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='5ce45b60'/>
	+ <parameter type-id='3fa542f0'/>
	+ <return type-id='48b5725f'/>
	+ </function-decl>
	+ <function-decl name='fnvlist_remove' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='5ce45b60'/>
	+ <parameter type-id='80f4b756'/>
	+ <return type-id='48b5725f'/>
	+ </function-decl>
	+ <function-decl name='fnvlist_lookup_boolean_value' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='5ce45b60'/>
	+ <parameter type-id='80f4b756'/>
	+ <return type-id='c19b74c3'/>
	+ </function-decl>
	+ <function-decl name='fnvlist_lookup_uint64_array' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='5ce45b60'/>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='4dd26a40'/>
	+ <return type-id='5d6479ae'/>
	+ </function-decl>
	+ <function-decl name='fletcher_4_native_varsize' mangled-name='fletcher_4_native_varsize' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fletcher_4_native_varsize'>
	+ <parameter type-id='eaa32e2f'/>
	+ <parameter type-id='9c313c2d'/>
	+ <parameter type-id='c24fc2ee'/>
	+ <return type-id='48b5725f'/>
	+ </function-decl>
	+ <function-decl name='fletcher_4_incremental_native' mangled-name='fletcher_4_incremental_native' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fletcher_4_incremental_native'>
	+ <parameter type-id='eaa32e2f'/>
	+ <parameter type-id='b59d7dce'/>
	+ <parameter type-id='eaa32e2f'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='fletcher_4_incremental_byteswap' mangled-name='fletcher_4_incremental_byteswap' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fletcher_4_incremental_byteswap'>
	+ <parameter type-id='eaa32e2f'/>
	+ <parameter type-id='b59d7dce'/>
	+ <parameter type-id='eaa32e2f'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	<function-decl name='zfs_send_progress' mangled-name='zfs_send_progress' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_send_progress'>
	<parameter type-id='9200a744' name='zhp'/>
	<parameter type-id='95e97e5e' name='fd'/>
	<parameter type-id='5d6479ae' name='bytes_written'/>
	<parameter type-id='5d6479ae' name='blocks_visited'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='zfs_send_resume_token_to_nvlist' mangled-name='zfs_send_resume_token_to_nvlist' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_send_resume_token_to_nvlist'>
	<parameter type-id='b0382bb3' name='hdl'/>
	<parameter type-id='80f4b756' name='token'/>
	<return type-id='5ce45b60'/>
	</function-decl>
	<function-decl name='zfs_send_resume' mangled-name='zfs_send_resume' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_send_resume'>
	<parameter type-id='b0382bb3' name='hdl'/>
	<parameter type-id='8def7735' name='flags'/>
	<parameter type-id='95e97e5e' name='outfd'/>
	<parameter type-id='80f4b756' name='resume_token'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='zfs_send_saved' mangled-name='zfs_send_saved' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_send_saved'>
	<parameter type-id='9200a744' name='zhp'/>
	<parameter type-id='8def7735' name='flags'/>
	<parameter type-id='95e97e5e' name='outfd'/>
	<parameter type-id='80f4b756' name='resume_token'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='zfs_send' mangled-name='zfs_send' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_send'>
	<parameter type-id='9200a744' name='zhp'/>
	<parameter type-id='80f4b756' name='fromsnap'/>
	<parameter type-id='80f4b756' name='tosnap'/>
	<parameter type-id='8def7735' name='flags'/>
	<parameter type-id='95e97e5e' name='outfd'/>
	<parameter type-id='72a26210' name='filter_func'/>
	<parameter type-id='eaa32e2f' name='cb_arg'/>
	<parameter type-id='857bb57e' name='debugnvp'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='zfs_send_one' mangled-name='zfs_send_one' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_send_one'>
	<parameter type-id='9200a744' name='zhp'/>
	<parameter type-id='80f4b756' name='from'/>
	<parameter type-id='95e97e5e' name='fd'/>
	<parameter type-id='8def7735' name='flags'/>
	<parameter type-id='80f4b756' name='redactbook'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='zfs_receive' mangled-name='zfs_receive' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_receive'>
	<parameter type-id='b0382bb3' name='hdl'/>
	<parameter type-id='80f4b756' name='tosnap'/>
	<parameter type-id='5ce45b60' name='props'/>
	<parameter type-id='4ea84b4f' name='flags'/>
	<parameter type-id='95e97e5e' name='infd'/>
	<parameter type-id='a3681dea' name='stream_avl'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='lzc_send_space_resume_redacted' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='bfbd3c8e'/>
	- <parameter type-id='9c313c2d'/>
	- <parameter type-id='9c313c2d'/>
	- <parameter type-id='9c313c2d'/>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='95e97e5e'/>
	- <parameter type-id='5d6479ae'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='lzc_rename' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='80f4b756'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='fnvlist_size' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='5ce45b60'/>
	- <return type-id='b59d7dce'/>
	- </function-decl>
	- <function-decl name='fnvlist_lookup_uint64_array' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='5ce45b60'/>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='4dd26a40'/>
	- <return type-id='5d6479ae'/>
	- </function-decl>
	- <function-decl name='__rawmemchr' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='eaa32e2f'/>
	- <parameter type-id='95e97e5e'/>
	- <return type-id='eaa32e2f'/>
	- </function-decl>
	- <function-decl name='lzc_send_resume_redacted' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='95e97e5e'/>
	- <parameter type-id='bfbd3c8e'/>
	- <parameter type-id='9c313c2d'/>
	- <parameter type-id='9c313c2d'/>
	- <parameter type-id='80f4b756'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='fnvlist_lookup_boolean_value' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='5ce45b60'/>
	- <parameter type-id='80f4b756'/>
	- <return type-id='c19b74c3'/>
	- </function-decl>
	- <function-decl name='__strndup' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='b59d7dce'/>
	- <return type-id='26a90f95'/>
	- </function-decl>
	- <function-decl name='nvlist_print' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='822cd80b'/>
	- <parameter type-id='5ce45b60'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	- <function-decl name='write' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='95e97e5e'/>
	- <parameter type-id='eaa32e2f'/>
	- <parameter type-id='b59d7dce'/>
	- <return type-id='79a0948f'/>
	- </function-decl>
	- <function-decl name='fletcher_4_incremental_native' mangled-name='fletcher_4_incremental_native' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fletcher_4_incremental_native'>
	- <parameter type-id='eaa32e2f'/>
	- <parameter type-id='b59d7dce'/>
	- <parameter type-id='eaa32e2f'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='lzc_send_space' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='80f4b756'/>
	+ <function-decl name='sprintf' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='26a90f95'/>
	<parameter type-id='80f4b756'/>
	- <parameter type-id='bfbd3c8e'/>
	- <parameter type-id='5d6479ae'/>
	+ <parameter is-variadic='yes'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='nvlist_lookup_boolean' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='5ce45b60'/>
	+ <function-decl name='perror' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='80f4b756'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='fletcher_4_incremental_byteswap' mangled-name='fletcher_4_incremental_byteswap' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fletcher_4_incremental_byteswap'>
	- <parameter type-id='eaa32e2f'/>
	- <parameter type-id='b59d7dce'/>
	- <parameter type-id='eaa32e2f'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='fnvlist_merge' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='5ce45b60'/>
	- <parameter type-id='5ce45b60'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='strcat' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='26a90f95'/>
	<parameter type-id='80f4b756'/>
	<return type-id='26a90f95'/>
	</function-decl>
	- <function-decl name='fnvlist_add_nvpair' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='5ce45b60'/>
	- <parameter type-id='3fa542f0'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	- <function-decl name='fnvlist_remove' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='5ce45b60'/>
	+ <function-decl name='strndup' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='80f4b756'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	- <function-decl name='nvpair_value_int32' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='3fa542f0'/>
	- <parameter type-id='4aafb922'/>
	- <return type-id='95e97e5e'/>
	+ <parameter type-id='b59d7dce'/>
	+ <return type-id='26a90f95'/>
	</function-decl>
	<function-decl name='time' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='b2eb2c3f'/>
	<return type-id='c9d12d66'/>
	</function-decl>
	- <function-decl name='lzc_receive_with_cmdprops' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='5ce45b60'/>
	- <parameter type-id='5ce45b60'/>
	- <parameter type-id='ae3e8ca6'/>
	- <parameter type-id='3502e3ff'/>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='c19b74c3'/>
	- <parameter type-id='c19b74c3'/>
	- <parameter type-id='c19b74c3'/>
	- <parameter type-id='95e97e5e'/>
	- <parameter type-id='41671bd6'/>
	- <parameter type-id='95e97e5e'/>
	- <parameter type-id='5d6479ae'/>
	- <parameter type-id='5d6479ae'/>
	- <parameter type-id='5d6479ae'/>
	- <parameter type-id='857bb57e'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='sprintf' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='26a90f95'/>
	- <parameter type-id='80f4b756'/>
	- <parameter is-variadic='yes'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='sleep' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='f0981eeb'/>
	- <return type-id='f0981eeb'/>
	- </function-decl>
	<function-decl name='localtime' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='9f201474'/>
	<return type-id='d915a820'/>
	</function-decl>
	- <function-decl name='fletcher_4_native_varsize' mangled-name='fletcher_4_native_varsize' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fletcher_4_native_varsize'>
	+ <function-decl name='write' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='95e97e5e'/>
	<parameter type-id='eaa32e2f'/>
	- <parameter type-id='9c313c2d'/>
	- <parameter type-id='c24fc2ee'/>
	- <return type-id='48b5725f'/>
	+ <parameter type-id='b59d7dce'/>
	+ <return type-id='79a0948f'/>
	+ </function-decl>
	+ <function-decl name='sleep' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='f0981eeb'/>
	+ <return type-id='f0981eeb'/>
	</function-decl>
	<function-decl name='uncompress' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='4c667223'/>
	<parameter type-id='60db3356'/>
	<parameter type-id='e8cb3e0e'/>
	<parameter type-id='5bbcce85'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zfs_get_pool_handle' mangled-name='zfs_get_pool_handle' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_get_pool_handle'>
	- <parameter type-id='fcd57163'/>
	- <return type-id='4c81de99'/>
	- </function-decl>
	- <function-decl name='lzc_send_redacted' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='95e97e5e'/>
	- <parameter type-id='bfbd3c8e'/>
	- <parameter type-id='80f4b756'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='libzfs_set_pipe_max' mangled-name='libzfs_set_pipe_max' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libzfs_set_pipe_max'>
	- <parameter type-id='95e97e5e'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	- <function-decl name='perror' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='80f4b756'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	<function-type size-in-bits='64' id='d2a5e211'>
	<parameter type-id='9200a744'/>
	<parameter type-id='eaa32e2f'/>
	<return type-id='c19b74c3'/>
	</function-type>
	</abi-instr>
	- <abi-instr version='1.0' address-size='64' path='libzfs_status.c' language='LANG_C89'>
	+ <abi-instr address-size='64' path='libzfs_status.c' language='LANG_C99'>
	<function-decl name='zpool_import_status' mangled-name='zpool_import_status' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_import_status'>
	<parameter type-id='5ce45b60' name='config'/>
	<parameter type-id='9b23c9ad' name='msgid'/>
	<parameter type-id='cec6f2e4' name='errata'/>
	<return type-id='d3dd6294'/>
	</function-decl>
	</abi-instr>
	- <abi-instr version='1.0' address-size='64' path='libzfs_util.c' language='LANG_C89'>
	+ <abi-instr address-size='64' path='libzfs_util.c' language='LANG_C99'>
	<class-decl name='__va_list_tag' size-in-bits='192' is-struct='yes' visibility='default' id='d5027220'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='gp_offset' type-id='f0981eeb' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='32'>
	<var-decl name='fp_offset' type-id='f0981eeb' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='overflow_arg_area' type-id='eaa32e2f' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='reg_save_area' type-id='eaa32e2f' visibility='default'/>
	</data-member>
	</class-decl>
	<type-decl name='double' size-in-bits='64' id='a0eb0f08'/>
	<array-type-def dimensions='1' type-id='95e97e5e' size-in-bits='192' id='e41bdf22'>
	- <subrange length='6' type-id='4c87fef4' id='52fa524b'/>
	+ <subrange length='6' type-id='7359adad' id='52fa524b'/>
	</array-type-def>
	<array-type-def dimensions='1' type-id='19cefcee' size-in-bits='160' alignment-in-bits='32' id='3fcf57d2'>
	- <subrange length='5' type-id='4c87fef4' id='53010e10'/>
	+ <subrange length='5' type-id='7359adad' id='53010e10'/>
	</array-type-def>
	- <typedef-decl name='zprop_get_cbdata_t' type-id='f3d3c319' id='f3d87113'/>
	+ <enum-decl name='zfs_get_column_t' naming-typedef-id='19cefcee' id='223bdcaa'>
	+ <underlying-type type-id='9cac1fee'/>
	+ <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='223bdcaa' id='19cefcee'/>
	<class-decl name='zprop_get_cbdata' size-in-bits='640' is-struct='yes' visibility='default' id='f3d3c319'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='cb_sources' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='32'>
	<var-decl name='cb_columns' type-id='3fcf57d2' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	<var-decl name='cb_colwidths' type-id='e41bdf22' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='384'>
	<var-decl name='cb_scripted' type-id='c19b74c3' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='416'>
	<var-decl name='cb_literal' type-id='c19b74c3' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='448'>
	<var-decl name='cb_first' type-id='c19b74c3' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='512'>
	<var-decl name='cb_proplist' type-id='3a9b2288' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='576'>
	<var-decl name='cb_type' type-id='2e45de5d' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='zfs_get_column_t' type-id='08f5ca20' id='19cefcee'/>
	- <enum-decl name='__anonymous_enum__' is-anonymous='yes' id='08f5ca20'>
	+ <typedef-decl name='zprop_get_cbdata_t' type-id='f3d3c319' id='f3d87113'/>
	+ <typedef-decl name='zprop_func' type-id='2e711a2a' id='1ec3747a'/>
	+ <enum-decl name='zprop_attr_t' naming-typedef-id='999701cc' id='77d05200'>
	<underlying-type type-id='9cac1fee'/>
	- <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'/>
	+ <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_func' type-id='2e711a2a' id='1ec3747a'/>
	- <typedef-decl name='__int32_t' type-id='95e97e5e' id='33f57a65'/>
	- <class-decl name='extmnttab' size-in-bits='320' is-struct='yes' visibility='default' id='0c544dc0'>
	+ <typedef-decl name='zprop_attr_t' type-id='77d05200' id='999701cc'/>
	+ <class-decl name='zfs_index' size-in-bits='128' is-struct='yes' visibility='default' id='87957af9'>
	<data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='mnt_special' type-id='26a90f95' visibility='default'/>
	+ <var-decl name='pi_name' type-id='80f4b756' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='mnt_mountp' type-id='26a90f95' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='mnt_fstype' type-id='26a90f95' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='192'>
	- <var-decl name='mnt_mntopts' type-id='26a90f95' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='256'>
	- <var-decl name='mnt_major' type-id='3502e3ff' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='288'>
	- <var-decl name='mnt_minor' type-id='3502e3ff' visibility='default'/>
	+ <var-decl name='pi_value' type-id='9c313c2d' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='zprop_desc_t' type-id='686c4527' id='ffa52b96'/>
	- <class-decl name='__anonymous_struct__' size-in-bits='704' is-struct='yes' is-anonymous='yes' naming-typedef-id='ffa52b96' visibility='default' id='686c4527'>
	+ <typedef-decl name='zprop_index_t' type-id='87957af9' id='64636ce3'/>
	+ <class-decl name='zprop_desc_t' size-in-bits='704' is-struct='yes' naming-typedef-id='ffa52b96' visibility='default' id='bbff5e4b'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='pd_name' type-id='80f4b756' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='pd_propnum' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='96'>
	<var-decl name='pd_proptype' type-id='31429eff' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='pd_strdefault' type-id='80f4b756' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	<var-decl name='pd_numdefault' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='256'>
	<var-decl name='pd_attr' type-id='999701cc' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='288'>
	<var-decl name='pd_types' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='320'>
	<var-decl name='pd_values' type-id='80f4b756' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='384'>
	<var-decl name='pd_colname' type-id='80f4b756' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='448'>
	<var-decl name='pd_rightalign' type-id='c19b74c3' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='480'>
	<var-decl name='pd_visible' type-id='c19b74c3' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='512'>
	<var-decl name='pd_zfs_mod_supported' type-id='c19b74c3' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='576'>
	<var-decl name='pd_table' type-id='c8bc397b' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='640'>
	<var-decl name='pd_table_size' type-id='b59d7dce' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='zprop_attr_t' type-id='40ed39d4' id='999701cc'/>
	- <enum-decl name='__anonymous_enum__1' is-anonymous='yes' id='40ed39d4'>
	- <underlying-type type-id='9cac1fee'/>
	- <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_index_t' type-id='87957af9' id='64636ce3'/>
	- <class-decl name='zfs_index' size-in-bits='128' is-struct='yes' visibility='default' id='87957af9'>
	+ <typedef-decl name='zprop_desc_t' type-id='bbff5e4b' id='ffa52b96'/>
	+ <class-decl name='extmnttab' size-in-bits='320' is-struct='yes' visibility='default' id='0c544dc0'>
	<data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='pi_name' type-id='80f4b756' visibility='default'/>
	+ <var-decl name='mnt_special' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='pi_value' type-id='9c313c2d' visibility='default'/>
	+ <var-decl name='mnt_mountp' type-id='26a90f95' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='128'>
	+ <var-decl name='mnt_fstype' type-id='26a90f95' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='192'>
	+ <var-decl name='mnt_mntopts' type-id='26a90f95' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='256'>
	+ <var-decl name='mnt_major' type-id='3502e3ff' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='288'>
	+ <var-decl name='mnt_minor' type-id='3502e3ff' visibility='default'/>
	</data-member>
	</class-decl>
	<pointer-type-def type-id='d5027220' size-in-bits='64' id='b7f2d5e6'/>
	<qualified-type-def type-id='26a90f95' const='yes' id='57de658a'/>
	<pointer-type-def type-id='57de658a' size-in-bits='64' id='f319fae0'/>
	<pointer-type-def type-id='9b23c9ad' size-in-bits='64' id='c0563f85'/>
	<qualified-type-def type-id='33f57a65' const='yes' id='21fd6035'/>
	<pointer-type-def type-id='21fd6035' size-in-bits='64' id='a0de50cd'/>
	<pointer-type-def type-id='a0de50cd' size-in-bits='64' id='24f95ba5'/>
	<qualified-type-def type-id='64636ce3' const='yes' id='072f7953'/>
	<pointer-type-def type-id='072f7953' size-in-bits='64' id='c8bc397b'/>
	<pointer-type-def type-id='0c544dc0' size-in-bits='64' id='394fc496'/>
	<pointer-type-def type-id='c70fa2e8' size-in-bits='64' id='2e711a2a'/>
	<pointer-type-def type-id='aca3bac8' size-in-bits='64' id='d33f11cb'/>
	+ <qualified-type-def type-id='d33f11cb' restrict='yes' id='5c53ba29'/>
	<pointer-type-def type-id='ffa52b96' size-in-bits='64' id='76c8174b'/>
	<pointer-type-def type-id='f3d87113' size-in-bits='64' id='0d2a0670'/>
	+ <function-decl name='zfs_version_kernel' mangled-name='zfs_version_kernel' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_version_kernel'>
	+ <parameter type-id='26a90f95'/>
	+ <parameter type-id='95e97e5e'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='libzfs_core_init' visibility='default' binding='global' size-in-bits='64'>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='libzfs_core_fini' visibility='default' binding='global' size-in-bits='64'>
	+ <return type-id='48b5725f'/>
	+ </function-decl>
	+ <function-decl name='libzfs_load_module' mangled-name='libzfs_load_module' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libzfs_load_module'>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='zpool_prop_unsupported' mangled-name='zpool_prop_unsupported' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_prop_unsupported'>
	+ <parameter type-id='80f4b756'/>
	+ <return type-id='c19b74c3'/>
	+ </function-decl>
	+ <function-decl name='zpool_feature_init' mangled-name='zpool_feature_init' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_feature_init'>
	+ <return type-id='48b5725f'/>
	+ </function-decl>
	+ <function-decl name='fletcher_4_init' mangled-name='fletcher_4_init' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fletcher_4_init'>
	+ <return type-id='48b5725f'/>
	+ </function-decl>
	+ <function-decl name='fletcher_4_fini' mangled-name='fletcher_4_fini' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fletcher_4_fini'>
	+ <return type-id='48b5725f'/>
	+ </function-decl>
	+ <function-decl name='zfs_prop_init' mangled-name='zfs_prop_init' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_init'>
	+ <return type-id='48b5725f'/>
	+ </function-decl>
	+ <function-decl name='zfs_prop_get_table' mangled-name='zfs_prop_get_table' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_get_table'>
	+ <return type-id='76c8174b'/>
	+ </function-decl>
	+ <function-decl name='zpool_prop_init' mangled-name='zpool_prop_init' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_prop_init'>
	+ <return type-id='48b5725f'/>
	+ </function-decl>
	+ <function-decl name='zpool_prop_get_table' mangled-name='zpool_prop_get_table' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_prop_get_table'>
	+ <return type-id='76c8174b'/>
	+ </function-decl>
	+ <function-decl name='zprop_iter_common' mangled-name='zprop_iter_common' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zprop_iter_common'>
	+ <parameter type-id='1ec3747a'/>
	+ <parameter type-id='eaa32e2f'/>
	+ <parameter type-id='c19b74c3'/>
	+ <parameter type-id='c19b74c3'/>
	+ <parameter type-id='2e45de5d'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='zprop_name_to_prop' mangled-name='zprop_name_to_prop' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zprop_name_to_prop'>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='2e45de5d'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='zprop_string_to_index' mangled-name='zprop_string_to_index' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zprop_string_to_index'>
	+ <parameter type-id='95e97e5e'/>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='5d6479ae'/>
	+ <parameter type-id='2e45de5d'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='zprop_values' mangled-name='zprop_values' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zprop_values'>
	+ <parameter type-id='95e97e5e'/>
	+ <parameter type-id='2e45de5d'/>
	+ <return type-id='80f4b756'/>
	+ </function-decl>
	+ <function-decl name='zprop_width' mangled-name='zprop_width' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zprop_width'>
	+ <parameter type-id='95e97e5e'/>
	+ <parameter type-id='37e3bd22'/>
	+ <parameter type-id='2e45de5d'/>
	+ <return type-id='b59d7dce'/>
	+ </function-decl>
	+ <function-decl name='zprop_valid_for_type' mangled-name='zprop_valid_for_type' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zprop_valid_for_type'>
	+ <parameter type-id='95e97e5e'/>
	+ <parameter type-id='2e45de5d'/>
	+ <parameter type-id='c19b74c3'/>
	+ <return type-id='c19b74c3'/>
	+ </function-decl>
	+ <function-decl name='getextmntent' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='394fc496'/>
	+ <parameter type-id='62f7a03d'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	<function-decl name='libzfs_errno' mangled-name='libzfs_errno' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libzfs_errno'>
	<parameter type-id='b0382bb3' name='hdl'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='libzfs_error_action' mangled-name='libzfs_error_action' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libzfs_error_action'>
	<parameter type-id='b0382bb3' name='hdl'/>
	<return type-id='80f4b756'/>
	</function-decl>
	<function-decl name='libzfs_error_description' mangled-name='libzfs_error_description' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libzfs_error_description'>
	<parameter type-id='b0382bb3' name='hdl'/>
	<return type-id='80f4b756'/>
	</function-decl>
	<function-decl name='libzfs_print_on_error' mangled-name='libzfs_print_on_error' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libzfs_print_on_error'>
	<parameter type-id='b0382bb3' name='hdl'/>
	<parameter type-id='c19b74c3' name='printerr'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='libzfs_run_process' mangled-name='libzfs_run_process' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libzfs_run_process'>
	<parameter type-id='80f4b756' name='path'/>
	<parameter type-id='9b23c9ad' name='argv'/>
	<parameter type-id='95e97e5e' name='flags'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='libzfs_run_process_get_stdout' mangled-name='libzfs_run_process_get_stdout' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libzfs_run_process_get_stdout'>
	<parameter type-id='80f4b756' name='path'/>
	<parameter type-id='9b23c9ad' name='argv'/>
	<parameter type-id='9b23c9ad' name='env'/>
	<parameter type-id='c0563f85' name='lines'/>
	<parameter type-id='7292109c' name='lines_cnt'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='libzfs_run_process_get_stdout_nopath' mangled-name='libzfs_run_process_get_stdout_nopath' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libzfs_run_process_get_stdout_nopath'>
	<parameter type-id='80f4b756' name='path'/>
	<parameter type-id='9b23c9ad' name='argv'/>
	<parameter type-id='9b23c9ad' name='env'/>
	<parameter type-id='c0563f85' name='lines'/>
	<parameter type-id='7292109c' name='lines_cnt'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='libzfs_free_str_array' mangled-name='libzfs_free_str_array' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libzfs_free_str_array'>
	<parameter type-id='9b23c9ad' name='strs'/>
	<parameter type-id='95e97e5e' name='count'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='libzfs_envvar_is_set' mangled-name='libzfs_envvar_is_set' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libzfs_envvar_is_set'>
	<parameter type-id='26a90f95' name='envvar'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	+ <function-decl name='libzfs_init' mangled-name='libzfs_init' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libzfs_init'>
	+ <return type-id='b0382bb3'/>
	+ </function-decl>
	<function-decl name='libzfs_fini' mangled-name='libzfs_fini' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libzfs_fini'>
	<parameter type-id='b0382bb3' name='hdl'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='zfs_path_to_zhandle' mangled-name='zfs_path_to_zhandle' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_path_to_zhandle'>
	<parameter type-id='b0382bb3' name='hdl'/>
	<parameter type-id='80f4b756' name='path'/>
	<parameter type-id='2e45de5d' name='argtype'/>
	<return type-id='9200a744'/>
	</function-decl>
	<function-decl name='zprop_print_one_property' mangled-name='zprop_print_one_property' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zprop_print_one_property'>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='0d2a0670' name='cbp'/>
	<parameter type-id='80f4b756' name='propname'/>
	<parameter type-id='80f4b756' name='value'/>
	<parameter type-id='a2256d42' name='sourcetype'/>
	<parameter type-id='80f4b756' name='source'/>
	<parameter type-id='80f4b756' name='recvd_value'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='libzfs_init' mangled-name='libzfs_init' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libzfs_init'>
	- <return type-id='b0382bb3'/>
	- </function-decl>
	<function-decl name='zprop_get_list' mangled-name='zprop_get_list' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zprop_get_list'>
	<parameter type-id='b0382bb3' name='hdl'/>
	<parameter type-id='26a90f95' name='props'/>
	<parameter type-id='e4378506' name='listp'/>
	<parameter type-id='2e45de5d' name='type'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='zprop_free_list' mangled-name='zprop_free_list' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zprop_free_list'>
	<parameter type-id='3a9b2288' name='pl'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='zprop_iter' mangled-name='zprop_iter' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zprop_iter'>
	<parameter type-id='1ec3747a' name='func'/>
	<parameter type-id='eaa32e2f' name='cb'/>
	<parameter type-id='c19b74c3' name='show_all'/>
	<parameter type-id='c19b74c3' name='ordered'/>
	<parameter type-id='2e45de5d' name='type'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='zfs_version_userland' mangled-name='zfs_version_userland' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_version_userland'>
	<parameter type-id='26a90f95' name='version'/>
	<parameter type-id='95e97e5e' name='len'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='zfs_version_print' mangled-name='zfs_version_print' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_version_print'>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='color_start' mangled-name='color_start' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='color_start'>
	<parameter type-id='26a90f95' name='color'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='color_end' mangled-name='color_end' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='color_end'>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='printf_color' mangled-name='printf_color' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='printf_color'>
	<parameter type-id='26a90f95' name='color'/>
	<parameter type-id='26a90f95' name='format'/>
	<parameter is-variadic='yes'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='realloc' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='eaa32e2f'/>
	- <parameter type-id='b59d7dce'/>
	- <return type-id='eaa32e2f'/>
	- </function-decl>
	- <function-decl name='waitpid' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='3629bad8'/>
	- <parameter type-id='7292109c'/>
	- <parameter type-id='95e97e5e'/>
	- <return type-id='3629bad8'/>
	- </function-decl>
	- <function-decl name='vfork' visibility='default' binding='global' size-in-bits='64'>
	- <return type-id='3629bad8'/>
	- </function-decl>
	- <function-decl name='execve' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='f319fae0'/>
	- <parameter type-id='f319fae0'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='_exit' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='95e97e5e'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	- <function-decl name='dup2' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='95e97e5e'/>
	- <parameter type-id='95e97e5e'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='execvpe' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='f319fae0'/>
	- <parameter type-id='f319fae0'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='execv' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='f319fae0'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='execvp' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='f319fae0'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='vsnprintf' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='26a90f95'/>
	- <parameter type-id='b59d7dce'/>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='b7f2d5e6'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='exit' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='95e97e5e'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	- <function-decl name='__ctype_toupper_loc' visibility='default' binding='global' size-in-bits='64'>
	- <return type-id='24f95ba5'/>
	- </function-decl>
	- <function-decl name='zprop_width' mangled-name='zprop_width' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zprop_width'>
	- <parameter type-id='95e97e5e'/>
	- <parameter type-id='37e3bd22'/>
	- <parameter type-id='2e45de5d'/>
	- <return type-id='b59d7dce'/>
	- </function-decl>
	- <function-decl name='vasprintf' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='9b23c9ad'/>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='b7f2d5e6'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='zprop_name_to_prop' mangled-name='zprop_name_to_prop' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zprop_name_to_prop'>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='2e45de5d'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='zprop_valid_for_type' mangled-name='zprop_valid_for_type' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zprop_valid_for_type'>
	- <parameter type-id='95e97e5e'/>
	- <parameter type-id='2e45de5d'/>
	- <parameter type-id='c19b74c3'/>
	- <return type-id='c19b74c3'/>
	- </function-decl>
	- <function-decl name='zpool_prop_unsupported' mangled-name='zpool_prop_unsupported' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_prop_unsupported'>
	- <parameter type-id='80f4b756'/>
	- <return type-id='c19b74c3'/>
	- </function-decl>
	- <function-decl name='strnlen' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='b59d7dce'/>
	- <return type-id='b59d7dce'/>
	- </function-decl>
	- <function-decl name='libzfs_core_fini' visibility='default' binding='global' size-in-bits='64'>
	- <return type-id='48b5725f'/>
	- </function-decl>
	- <function-decl name='regfree' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='d33f11cb'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	- <function-decl name='fletcher_4_fini' mangled-name='fletcher_4_fini' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fletcher_4_fini'>
	- <return type-id='48b5725f'/>
	- </function-decl>
	- <function-decl name='getextmntent' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='394fc496'/>
	- <parameter type-id='62f7a03d'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='strtod' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='9b23c9ad'/>
	- <return type-id='a0eb0f08'/>
	- </function-decl>
	<function-decl name='pow' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='a0eb0f08'/>
	<parameter type-id='a0eb0f08'/>
	<return type-id='a0eb0f08'/>
	</function-decl>
	- <function-decl name='zpool_prop_get_table' mangled-name='zpool_prop_get_table' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_prop_get_table'>
	- <return type-id='76c8174b'/>
	- </function-decl>
	- <function-decl name='zfs_prop_get_table' mangled-name='zfs_prop_get_table' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_get_table'>
	- <return type-id='76c8174b'/>
	+ <function-decl name='__ctype_toupper_loc' visibility='default' binding='global' size-in-bits='64'>
	+ <return type-id='24f95ba5'/>
	</function-decl>
	- <function-decl name='libzfs_load_module' mangled-name='libzfs_load_module' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libzfs_load_module'>
	+ <function-decl name='regcomp' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='5c53ba29'/>
	+ <parameter type-id='9d26089a'/>
	+ <parameter type-id='95e97e5e'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='regcomp' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='regfree' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='d33f11cb'/>
	+ <return type-id='48b5725f'/>
	+ </function-decl>
	+ <function-decl name='vfprintf' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='e75a27e9'/>
	+ <parameter type-id='9d26089a'/>
	+ <parameter type-id='b7f2d5e6'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='vsnprintf' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='26a90f95'/>
	+ <parameter type-id='b59d7dce'/>
	<parameter type-id='80f4b756'/>
	- <parameter type-id='95e97e5e'/>
	+ <parameter type-id='b7f2d5e6'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='libzfs_core_init' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='vasprintf' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='8c85230f'/>
	+ <parameter type-id='9d26089a'/>
	+ <parameter type-id='b7f2d5e6'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zfs_prop_init' mangled-name='zfs_prop_init' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_init'>
	- <return type-id='48b5725f'/>
	+ <function-decl name='strtod' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='9d26089a'/>
	+ <parameter type-id='8c85230f'/>
	+ <return type-id='a0eb0f08'/>
	</function-decl>
	- <function-decl name='zpool_prop_init' mangled-name='zpool_prop_init' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_prop_init'>
	- <return type-id='48b5725f'/>
	+ <function-decl name='realloc' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='eaa32e2f'/>
	+ <parameter type-id='b59d7dce'/>
	+ <return type-id='eaa32e2f'/>
	</function-decl>
	- <function-decl name='zpool_feature_init' mangled-name='zpool_feature_init' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_feature_init'>
	+ <function-decl name='exit' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='95e97e5e'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='fletcher_4_init' mangled-name='fletcher_4_init' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fletcher_4_init'>
	- <return type-id='48b5725f'/>
	+ <function-decl name='strnlen' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='b59d7dce'/>
	+ <return type-id='b59d7dce'/>
	</function-decl>
	- <function-decl name='zprop_string_to_index' mangled-name='zprop_string_to_index' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zprop_string_to_index'>
	+ <function-decl name='waitpid' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='3629bad8'/>
	+ <parameter type-id='7292109c'/>
	<parameter type-id='95e97e5e'/>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='5d6479ae'/>
	- <parameter type-id='2e45de5d'/>
	- <return type-id='95e97e5e'/>
	+ <return type-id='3629bad8'/>
	</function-decl>
	- <function-decl name='zprop_values' mangled-name='zprop_values' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zprop_values'>
	+ <function-decl name='dup2' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='95e97e5e'/>
	- <parameter type-id='2e45de5d'/>
	- <return type-id='80f4b756'/>
	+ <parameter type-id='95e97e5e'/>
	+ <return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zprop_iter_common' mangled-name='zprop_iter_common' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zprop_iter_common'>
	- <parameter type-id='1ec3747a'/>
	- <parameter type-id='eaa32e2f'/>
	- <parameter type-id='c19b74c3'/>
	- <parameter type-id='c19b74c3'/>
	- <parameter type-id='2e45de5d'/>
	+ <function-decl name='execve' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='f319fae0'/>
	+ <parameter type-id='f319fae0'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zfs_version_kernel' mangled-name='zfs_version_kernel' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_version_kernel'>
	- <parameter type-id='26a90f95'/>
	- <parameter type-id='95e97e5e'/>
	+ <function-decl name='execv' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='f319fae0'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='vfprintf' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='822cd80b'/>
	+ <function-decl name='execvp' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='80f4b756'/>
	- <parameter type-id='b7f2d5e6'/>
	+ <parameter type-id='f319fae0'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='execvpe' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='f319fae0'/>
	+ <parameter type-id='f319fae0'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	+ <function-decl name='_exit' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='95e97e5e'/>
	+ <return type-id='48b5725f'/>
	+ </function-decl>
	+ <function-decl name='vfork' visibility='default' binding='global' size-in-bits='64'>
	+ <return type-id='3629bad8'/>
	+ </function-decl>
	<function-type size-in-bits='64' id='c70fa2e8'>
	<parameter type-id='95e97e5e'/>
	<parameter type-id='eaa32e2f'/>
	<return type-id='95e97e5e'/>
	</function-type>
	</abi-instr>
	- <abi-instr version='1.0' address-size='64' path='os/linux/libzfs_mount_os.c' language='LANG_C89'>
	+ <abi-instr address-size='64' path='os/linux/libzfs_mount_os.c' language='LANG_C99'>
	<pointer-type-def type-id='7359adad' size-in-bits='64' id='1d2c2b85'/>
	+ <function-decl name='mount' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='7359adad'/>
	+ <parameter type-id='eaa32e2f'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='umount2' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='95e97e5e'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='geteuid' visibility='default' binding='global' size-in-bits='64'>
	+ <return type-id='cc5fcceb'/>
	+ </function-decl>
	<function-decl name='zfs_parse_mount_options' mangled-name='zfs_parse_mount_options' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_parse_mount_options'>
	<parameter type-id='26a90f95' name='mntopts'/>
	<parameter type-id='1d2c2b85' name='mntflags'/>
	<parameter type-id='1d2c2b85' name='zfsflags'/>
	<parameter type-id='95e97e5e' name='sloppy'/>
	<parameter type-id='26a90f95' name='badopt'/>
	<parameter type-id='26a90f95' name='mtabopt'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='zfs_adjust_mount_options' mangled-name='zfs_adjust_mount_options' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_adjust_mount_options'>
	<parameter type-id='9200a744' name='zhp'/>
	<parameter type-id='80f4b756' name='mntpoint'/>
	<parameter type-id='26a90f95' name='mntopts'/>
	<parameter type-id='26a90f95' name='mtabopt'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='zfs_mount_delegation_check' mangled-name='zfs_mount_delegation_check' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_mount_delegation_check'>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='mount' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='7359adad'/>
	- <parameter type-id='eaa32e2f'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='umount2' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='95e97e5e'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='geteuid' visibility='default' binding='global' size-in-bits='64'>
	- <return type-id='cc5fcceb'/>
	- </function-decl>
	</abi-instr>
	- <abi-instr version='1.0' address-size='64' path='os/linux/libzfs_pool_os.c' language='LANG_C89'>
	+ <abi-instr address-size='64' path='os/linux/libzfs_pool_os.c' language='LANG_C99'>
	<array-type-def dimensions='1' type-id='a84c031d' size-in-bits='288' id='16e6f2c6'>
	- <subrange length='36' type-id='4c87fef4' id='ae666bde'/>
	+ <subrange length='36' type-id='7359adad' id='ae666bde'/>
	</array-type-def>
	<array-type-def dimensions='1' type-id='a65ae39c' size-in-bits='960' id='fa198beb'>
	- <subrange length='1' type-id='4c87fef4' id='52f813b4'/>
	+ <subrange length='1' type-id='7359adad' id='52f813b4'/>
	</array-type-def>
	<array-type-def dimensions='1' type-id='3502e3ff' size-in-bits='384' id='dba89ba3'>
	- <subrange length='12' type-id='4c87fef4' id='84827bdc'/>
	+ <subrange length='12' type-id='7359adad' id='84827bdc'/>
	</array-type-def>
	<array-type-def dimensions='1' type-id='3502e3ff' size-in-bits='256' id='01d84ed4'>
	- <subrange length='8' type-id='4c87fef4' id='56e0c0b1'/>
	+ <subrange length='8' type-id='7359adad' id='56e0c0b1'/>
	</array-type-def>
	+ <class-decl name='dk_part' size-in-bits='960' is-struct='yes' visibility='default' id='a65ae39c'>
	+ <data-member access='public' layout-offset-in-bits='0'>
	+ <var-decl name='p_start' type-id='804dc465' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='64'>
	+ <var-decl name='p_size' type-id='804dc465' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='128'>
	+ <var-decl name='p_guid' type-id='214f32ea' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='256'>
	+ <var-decl name='p_tag' type-id='d908a348' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='272'>
	+ <var-decl name='p_flag' type-id='d908a348' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='288'>
	+ <var-decl name='p_name' type-id='16e6f2c6' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='576'>
	+ <var-decl name='p_uguid' type-id='214f32ea' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='704'>
	+ <var-decl name='p_resv' type-id='01d84ed4' visibility='default'/>
	+ </data-member>
	+ </class-decl>
	<class-decl name='dk_gpt' size-in-bits='1920' is-struct='yes' visibility='default' id='dd4a2e5a'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='efi_version' type-id='3502e3ff' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='32'>
	<var-decl name='efi_nparts' type-id='3502e3ff' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='efi_part_size' type-id='3502e3ff' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='96'>
	<var-decl name='efi_lbasize' type-id='3502e3ff' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='efi_last_lba' type-id='804dc465' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	<var-decl name='efi_first_u_lba' type-id='804dc465' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='256'>
	<var-decl name='efi_last_u_lba' type-id='804dc465' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='320'>
	<var-decl name='efi_disk_uguid' type-id='214f32ea' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='448'>
	<var-decl name='efi_flags' type-id='3502e3ff' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='480'>
	<var-decl name='efi_reserved1' type-id='3502e3ff' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='512'>
	<var-decl name='efi_altern_lba' type-id='804dc465' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='576'>
	<var-decl name='efi_reserved' type-id='dba89ba3' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='960'>
	<var-decl name='efi_parts' type-id='fa198beb' visibility='default'/>
	</data-member>
	</class-decl>
	<class-decl name='uuid' size-in-bits='128' is-struct='yes' visibility='default' id='214f32ea'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='time_low' type-id='8f92235e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='32'>
	<var-decl name='time_mid' type-id='149c6638' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='48'>
	<var-decl name='time_hi_and_version' type-id='149c6638' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='clock_seq_hi_and_reserved' type-id='b96825af' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='72'>
	<var-decl name='clock_seq_low' type-id='b96825af' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='80'>
	<var-decl name='node_addr' type-id='0f562bd0' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='uint16_t' type-id='8efea9e5' id='149c6638'/>
	- <class-decl name='dk_part' size-in-bits='960' is-struct='yes' visibility='default' id='a65ae39c'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='p_start' type-id='804dc465' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='p_size' type-id='804dc465' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='p_guid' type-id='214f32ea' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='256'>
	- <var-decl name='p_tag' type-id='d908a348' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='272'>
	- <var-decl name='p_flag' type-id='d908a348' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='288'>
	- <var-decl name='p_name' type-id='16e6f2c6' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='576'>
	- <var-decl name='p_uguid' type-id='214f32ea' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='704'>
	- <var-decl name='p_resv' type-id='01d84ed4' visibility='default'/>
	- </data-member>
	- </class-decl>
	<typedef-decl name='ushort_t' type-id='8efea9e5' id='d908a348'/>
	+ <typedef-decl name='uint16_t' type-id='253c2d2a' id='149c6638'/>
	+ <typedef-decl name='__uint16_t' type-id='8efea9e5' id='253c2d2a'/>
	<pointer-type-def type-id='dd4a2e5a' size-in-bits='64' id='0d8119a8'/>
	<pointer-type-def type-id='0d8119a8' size-in-bits='64' id='c43b27a6'/>
	- <function-decl name='zpool_label_disk' mangled-name='zpool_label_disk' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_label_disk'>
	- <parameter type-id='b0382bb3' name='hdl'/>
	- <parameter type-id='4c81de99' name='zhp'/>
	- <parameter type-id='80f4b756' name='name'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='efi_alloc_and_read' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='zpool_label_disk_wait' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='80f4b756'/>
	<parameter type-id='95e97e5e'/>
	- <parameter type-id='c43b27a6'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='efi_free' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='0d8119a8'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	- <function-decl name='efi_use_whole_disk' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='95e97e5e'/>
	+ <function-decl name='zfs_append_partition' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='26a90f95'/>
	+ <parameter type-id='b59d7dce'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='fsync' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='efi_alloc_and_init' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='95e97e5e'/>
	+ <parameter type-id='8f92235e'/>
	+ <parameter type-id='c43b27a6'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='rand' visibility='default' binding='global' size-in-bits='64'>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='efi_alloc_and_init' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='efi_alloc_and_read' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='95e97e5e'/>
	- <parameter type-id='8f92235e'/>
	<parameter type-id='c43b27a6'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='efi_write' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='95e97e5e'/>
	<parameter type-id='0d8119a8'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='efi_rescan' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='95e97e5e'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zfs_append_partition' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='26a90f95'/>
	- <parameter type-id='b59d7dce'/>
	- <return type-id='95e97e5e'/>
	+ <function-decl name='efi_free' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='0d8119a8'/>
	+ <return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='zpool_label_disk_wait' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='80f4b756'/>
	+ <function-decl name='efi_use_whole_disk' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='95e97e5e'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- </abi-instr>
	- <abi-instr version='1.0' address-size='64' path='os/linux/libzfs_sendrecv_os.c' language='LANG_C89'>
	- <function-decl name='fscanf' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='822cd80b'/>
	- <parameter type-id='80f4b756'/>
	- <parameter is-variadic='yes'/>
	+ <function-decl name='rand' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='fcntl' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='95e97e5e'/>
	+ <function-decl name='fsync' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='95e97e5e'/>
	- <parameter is-variadic='yes'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='zpool_label_disk' mangled-name='zpool_label_disk' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_label_disk'>
	+ <parameter type-id='b0382bb3' name='hdl'/>
	+ <parameter type-id='4c81de99' name='zhp'/>
	+ <parameter type-id='80f4b756' name='name'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	</abi-instr>
	- <abi-instr version='1.0' address-size='64' path='os/linux/libzfs_util_os.c' language='LANG_C89'>
	- <typedef-decl name='clockid_t' type-id='08f9a87a' id='a1c3b834'/>
	- <typedef-decl name='__clockid_t' type-id='95e97e5e' id='08f9a87a'/>
	+ <abi-instr address-size='64' path='os/linux/libzfs_util_os.c' language='LANG_C99'>
	<typedef-decl name='__useconds_t' type-id='f0981eeb' id='4e80d4b1'/>
	+ <typedef-decl name='__clockid_t' type-id='95e97e5e' id='08f9a87a'/>
	+ <typedef-decl name='clockid_t' type-id='08f9a87a' id='a1c3b834'/>
	<pointer-type-def type-id='a9c79a1f' size-in-bits='64' id='3d83ba87'/>
	- <function-decl name='libzfs_error_init' mangled-name='libzfs_error_init' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libzfs_error_init'>
	- <parameter type-id='95e97e5e' name='error'/>
	- <return type-id='80f4b756'/>
	- </function-decl>
	- <function-decl name='access' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='95e97e5e'/>
	+ <function-decl name='sched_yield' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='clock_gettime' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='a1c3b834'/>
	<parameter type-id='3d83ba87'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='sched_yield' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='access' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='95e97e5e'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='usleep' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='4e80d4b1'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	+ <function-decl name='libzfs_error_init' mangled-name='libzfs_error_init' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libzfs_error_init'>
	+ <parameter type-id='95e97e5e' name='error'/>
	+ <return type-id='80f4b756'/>
	+ </function-decl>
	</abi-instr>
	</abi-corpus>
	diff --git a/sys/contrib/openzfs/lib/libzfs/libzfs_dataset.c b/sys/contrib/openzfs/lib/libzfs/libzfs_dataset.c
	index 2accfff28a6e..8251c434f81e 100644
	--- a/sys/contrib/openzfs/lib/libzfs/libzfs_dataset.c
	+++ b/sys/contrib/openzfs/lib/libzfs/libzfs_dataset.c
	@@ -1,5558 +1,5557 @@
	/*
	* 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, "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, "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=%llu' property: must be zero "
	"or a power of 2 from 512B to %s"),
	propname, (unsigned long long)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;
	}
	+ fallthrough;
	}

	- /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 \|\| 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));
	+ fallthrough;
	#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) {
	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;

	return (zfs_standard_error_fmt(hdl, errno,
	dgettext(TEXT_DOMAIN,
	"cannot get used/quota for %s"), zc.zc_name));
	}
	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(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(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(hdl, errno, errbuf);
	break;
	}
	} else {
	/* success */
	int rc = nvlist_unpack(nvbuf, zc.zc_nvlist_dst_size, nvl, 0);
	if (rc) {
	err = zfs_standard_error_fmt(hdl, rc, dgettext(
	TEXT_DOMAIN, "cannot get permissions on '%s'"),
	zc.zc_name);
	}
	}

	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(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(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 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_pool.c b/sys/contrib/openzfs/lib/libzfs/libzfs_pool.c
	index 58056ac70377..c6884538df1d 100644
	--- a/sys/contrib/openzfs/lib/libzfs/libzfs_pool.c
	+++ b/sys/contrib/openzfs/lib/libzfs/libzfs_pool.c
	@@ -1,4950 +1,4950 @@
	/*
	* 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 */
	+ 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 */
	+ 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 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 %llu is invalid."),
	propname, (unsigned long long)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 %llu is invalid, "
	"only values between %" PRId32 " and %"
	PRId32 " are allowed."),
	propname, (unsigned long long)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, report, 1024)) {
	case ZPOOL_COMPATIBILITY_OK:
	case ZPOOL_COMPATIBILITY_WARNTOKEN:
	break;
	case ZPOOL_COMPATIBILITY_BADFILE:
	case ZPOOL_COMPATIBILITY_BADTOKEN:
	case ZPOOL_COMPATIBILITY_NOFILES:
	zfs_error_aux(hdl, "%s", 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"};

	(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_fmt(zhp->zpool_hdl, EZFS_ACTIVE_SPARE,
	dgettext(TEXT_DOMAIN, "cannot export '%s'"),
	zhp->zpool_name));
	default:
	return (zpool_standard_error_fmt(zhp->zpool_hdl, errno,
	dgettext(TEXT_DOMAIN, "cannot export '%s'"),
	zhp->zpool_name));
	}
	}

	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, "%s", 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"};

	if (zfs_ioctl(hdl, ZFS_IOC_EVENTS_CLEAR, &zc) != 0)
	return (zpool_standard_error(hdl, errno,
	dgettext(TEXT_DOMAIN, "cannot clear events")));

	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
	* 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.
	*
	* "report" if not NULL will be populated with a suitable status message.
	*
	* Return values:
	* ZPOOL_COMPATIBILITY_OK : files read and parsed ok
	* ZPOOL_COMPATIBILITY_BADFILE : file too big or not a text file
	* 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 compat, boolean_t features, char *report,
	size_t rlen)
	{
	int sdirfd, ddirfd, featfd;
	struct stat fs;
	char *fc;
	char ps, ls, *ws;
	char file, line, *word;

	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 (compat == NULL \|\| compat[0] == '\0' \|\|
	strcmp(compat, ZPOOL_COMPAT_OFF) == 0) {
	if (features != NULL)
	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(compat, ZPOOL_COMPAT_LEGACY) == 0) {
	if (features != NULL)
	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 (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().
	*/

	/* O_PATH safer than O_RDONLY if system allows it */
	#if defined(O_PATH)
	#define ZC_DIR_FLAGS (O_DIRECTORY \| O_CLOEXEC \| O_PATH)
	#else
	#define ZC_DIR_FLAGS (O_DIRECTORY \| O_CLOEXEC \| O_RDONLY)
	#endif

	sdirfd = open(ZPOOL_SYSCONF_COMPAT_D, ZC_DIR_FLAGS);
	ddirfd = open(ZPOOL_DATA_COMPAT_D, ZC_DIR_FLAGS);

	(void) strlcpy(l_compat, compat, ZFS_MAXPROPLEN);

	for (file = strtok_r(l_compat, ",", &ps);
	file != NULL;
	file = strtok_r(NULL, ",", &ps)) {

	boolean_t l_features[SPA_FEATURES];

	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;
	}

	/* 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);
	strlcat(err_badfile, file, ZFS_MAXPROPLEN);
	strlcat(err_badfile, " ", ZFS_MAXPROPLEN);
	ret_badfile = B_TRUE;
	continue;
	}

	/* Prefault the file if system allows */
	#if defined(MAP_POPULATE)
	#define ZC_MMAP_FLAGS (MAP_PRIVATE \| MAP_POPULATE)
	#elif defined(MAP_PREFAULT_READ)
	#define ZC_MMAP_FLAGS (MAP_PRIVATE \| MAP_PREFAULT_READ)
	#else
	#define ZC_MMAP_FLAGS (MAP_PRIVATE)
	#endif

	/* private mmap() so we can strtok safely */
	fc = (char *)mmap(NULL, fs.st_size, PROT_READ \| PROT_WRITE,
	ZC_MMAP_FLAGS, featfd, 0);
	(void) close(featfd);

	/* map ok, and last character == newline? */
	if (fc == MAP_FAILED \|\| fc[fs.st_size - 1] != '\n') {
	(void) munmap((void *) fc, fs.st_size);
	strlcat(err_badfile, file, ZFS_MAXPROPLEN);
	strlcat(err_badfile, " ", ZFS_MAXPROPLEN);
	ret_badfile = B_TRUE;
	continue;
	}

	ret_nofiles = B_FALSE;

	for (uint_t i = 0; i < SPA_FEATURES; i++)
	l_features[i] = B_FALSE;

	/* replace final newline with NULL to ensure string ends */
	fc[fs.st_size - 1] = '\0';

	for (line = strtok_r(fc, "\n", &ls);
	line != NULL;
	line = strtok_r(NULL, "\n", &ls)) {
	/* discard comments */
	char *r = strchr(line, '#');
	if (r != NULL)
	*r = '\0';

	for (word = strtok_r(line, ", \t", &ws);
	word != NULL;
	word = strtok_r(NULL, ", \t", &ws)) {
	/* Find matching feature name */
	uint_t f;
	for (f = 0; f < SPA_FEATURES; f++) {
	zfeature_info_t *fi =
	&spa_feature_table[f];
	if (strcmp(word, fi->fi_uname) == 0) {
	l_features[f] = B_TRUE;
	break;
	}
	}
	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;
	}
	}
	(void) munmap((void *) fc, fs.st_size);

	if (features != NULL)
	for (uint_t i = 0; i < SPA_FEATURES; i++)
	features[i] &= l_features[i];
	}
	(void) close(sdirfd);
	(void) close(ddirfd);

	/* 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 4340ff9552ef..86ff8c91a91e 100644
	--- a/sys/contrib/openzfs/lib/libzfs/libzfs_sendrecv.c
	+++ b/sys/contrib/openzfs/lib/libzfs/libzfs_sendrecv.c
	@@ -1,5202 +1,5202 @@
	/*
	* 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, 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 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, "%s", 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:
	case EINVAL:
	zfs_error_aux(hdl, "%s", 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, "%s", 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, "%s", 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;
	if (lzc_flags & LZC_SEND_FLAG_RAW)
	tmpflags.raw = B_TRUE;
	if (lzc_flags & LZC_SEND_FLAG_SAVED)
	tmpflags.saved = 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, "%s", 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 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, 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, "%s", 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, "%s", 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->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 \| 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;
	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, 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, "%s", 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)
	return (zfs_standard_error_fmt(hdl, error,
	dgettext(TEXT_DOMAIN,
	"progress thread exited nonzero")));
	}

	if (flags->props \|\| flags->holds \|\| flags->backup) {
	/* Write the final end record. */
	err = send_conclusion_record(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, "%s", 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, 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;

	/* 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 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_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 */
	+ fallthrough;
	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 = %llx"),
	(unsigned long long)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_util.c b/sys/contrib/openzfs/lib/libzfs/libzfs_util.c
	index 4170cf019f7e..6e57d8e42563 100644
	--- a/sys/contrib/openzfs/lib/libzfs/libzfs_util.c
	+++ b/sys/contrib/openzfs/lib/libzfs/libzfs_util.c
	@@ -1,2102 +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, "%s", 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 */
	+ 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, "%s", 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) {
	(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) && pipe2(link, O_CLOEXEC) == -1)
	return (-EPIPE);

	pid = vfork();
	if (pid == 0) {
	/* Child process */
	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);
	}

	if (!(flags & STDERR_VERBOSE))
	(void) dup2(devnull_fd, STDERR_FILENO);

	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\|O_CLOEXEC)) < 0) {
	free(hdl);
	return (NULL);
	}

	#ifdef HAVE_SETMNTENT
	if ((hdl->libzfs_mnttab = setmntent(MNTTAB, "re")) == NULL) {
	#else
	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, "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_core/libzfs_core.abi b/sys/contrib/openzfs/lib/libzfs_core/libzfs_core.abi
	index ce9cc89f019b..c15cb3afbfca 100644
	--- a/sys/contrib/openzfs/lib/libzfs_core/libzfs_core.abi
	+++ b/sys/contrib/openzfs/lib/libzfs_core/libzfs_core.abi
	@@ -1,5129 +1,4485 @@
	-<abi-corpus architecture='elf-amd-x86_64' soname='libzfs_core.so.3'>
	+<abi-corpus version='2.0' architecture='elf-amd-x86_64' soname='libzfs_core.so.3'>
	<elf-needed>
	<dependency name='libuuid.so.1'/>
	<dependency name='libz.so.1'/>
	- <dependency name='librt.so.1'/>
	<dependency name='libm.so.6'/>
	<dependency name='libblkid.so.1'/>
	<dependency name='libudev.so.1'/>
	<dependency name='libnvpair.so.3'/>
	- <dependency name='libpthread.so.0'/>
	+ <dependency name='libtirpc.so.3'/>
	<dependency name='libc.so.6'/>
	<dependency name='ld-linux-x86-64.so.2'/>
	</elf-needed>
	<elf-function-symbols>
	- <elf-symbol name='_fini' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	- <elf-symbol name='_init' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='_sol_getmntent' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_add_16' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_add_16_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_add_32' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_add_32_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_add_64' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_add_64_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_add_8' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_add_8_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_add_char' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_add_char_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_add_int' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_add_int_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_add_long' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_add_long_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_add_ptr' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_add_ptr_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_add_short' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_add_short_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_and_16' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_and_16_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_and_32' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_and_32_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_and_64' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_and_64_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_and_8' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_and_8_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_and_uchar' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_and_uchar_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_and_uint' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_and_uint_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_and_ulong' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_and_ulong_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_and_ushort' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_and_ushort_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_cas_16' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_cas_32' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_cas_64' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_cas_8' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_cas_ptr' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_cas_uchar' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_cas_uint' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_cas_ulong' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_cas_ushort' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_clear_long_excl' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_dec_16' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_dec_16_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_dec_32' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_dec_32_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_dec_64' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_dec_64_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_dec_8' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_dec_8_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_dec_uchar' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_dec_uchar_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_dec_uint' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_dec_uint_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_dec_ulong' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_dec_ulong_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_dec_ushort' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_dec_ushort_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_inc_16' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_inc_16_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_inc_32' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_inc_32_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_inc_64' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_inc_64_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_inc_8' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_inc_8_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_inc_uchar' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_inc_uchar_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_inc_uint' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_inc_uint_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_inc_ulong' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_inc_ulong_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_inc_ushort' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_inc_ushort_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_or_16' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_or_16_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_or_32' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_or_32_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_or_64' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_or_64_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_or_8' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_or_8_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_or_uchar' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_or_uchar_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_or_uint' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_or_uint_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_or_ulong' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_or_ulong_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_or_ushort' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_or_ushort_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_set_long_excl' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_sub_16' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_sub_16_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_sub_32' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_sub_32_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_sub_64' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_sub_64_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_sub_8' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_sub_8_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_sub_char' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_sub_char_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_sub_int' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_sub_int_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_sub_long' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_sub_long_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_sub_ptr' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_sub_ptr_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_sub_short' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_sub_short_nv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_swap_16' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_swap_32' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_swap_64' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_swap_8' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_swap_ptr' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_swap_uchar' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_swap_uint' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_swap_ulong' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='atomic_swap_ushort' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='avl_add' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='avl_create' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='avl_destroy' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='avl_destroy_nodes' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='avl_find' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='avl_first' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='avl_insert' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='avl_insert_here' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='avl_is_empty' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='avl_last' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='avl_nearest' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='avl_numnodes' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='avl_remove' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='avl_swap' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='avl_update' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='avl_update_gt' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='avl_update_lt' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='avl_walk' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='efi_alloc_and_init' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='efi_alloc_and_read' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='efi_auto_sense' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='efi_err_check' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='efi_free' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='efi_rescan' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='efi_type' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='efi_use_whole_disk' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='efi_write' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	+ <elf-symbol name='for_each_vdev_cb' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	+ <elf-symbol name='for_each_vdev_in_nvlist' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='get_system_hostid' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='getexecname' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='getextmntent' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='getmntany' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='getzoneid' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='is_mpath_whole_disk' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='label_paths' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='libspl_assertf' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='libzfs_core_fini' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='libzfs_core_init' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='list_create' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='list_destroy' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='list_head' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='list_insert_after' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='list_insert_before' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='list_insert_head' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='list_insert_tail' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='list_is_empty' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='list_link_active' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='list_link_init' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='list_link_replace' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='list_move_tail' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='list_next' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='list_prev' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='list_remove' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='list_remove_head' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='list_remove_tail' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='list_tail' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='lzc_bookmark' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='lzc_change_key' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='lzc_channel_program' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='lzc_channel_program_nosync' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='lzc_clone' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='lzc_create' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='lzc_destroy' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='lzc_destroy_bookmarks' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='lzc_destroy_snaps' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='lzc_exists' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='lzc_get_bookmark_props' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='lzc_get_bookmarks' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='lzc_get_bootenv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='lzc_get_holds' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='lzc_hold' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='lzc_initialize' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='lzc_load_key' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='lzc_pool_checkpoint' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='lzc_pool_checkpoint_discard' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='lzc_promote' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='lzc_receive' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='lzc_receive_one' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='lzc_receive_resumable' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='lzc_receive_with_cmdprops' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='lzc_receive_with_header' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='lzc_redact' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='lzc_release' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='lzc_rename' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='lzc_reopen' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='lzc_rollback' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='lzc_rollback_to' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='lzc_send' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='lzc_send_redacted' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='lzc_send_resume' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='lzc_send_resume_redacted' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='lzc_send_space' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='lzc_send_space_resume_redacted' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='lzc_set_bootenv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='lzc_snaprange_space' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='lzc_snapshot' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='lzc_sync' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='lzc_trim' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='lzc_unload_key' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='lzc_wait' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='lzc_wait_fs' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='lzc_wait_tag' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='membar_consumer' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='membar_enter' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='membar_exit' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='membar_producer' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='mkdirp' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='print_timestamp' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='slice_cache_compare' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='spl_pagesize' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='strlcat' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='strlcpy' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='tpool_abandon' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='tpool_create' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='tpool_destroy' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='tpool_dispatch' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='tpool_member' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='tpool_resume' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='tpool_suspend' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='tpool_suspended' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='tpool_wait' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='update_vdev_config_dev_strs' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	+ <elf-symbol name='update_vdevs_config_dev_sysfs_path' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_append_partition' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_dev_flush' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_dev_is_dm' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_dev_is_whole_disk' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_device_get_devid' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_device_get_physical' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_get_enclosure_sysfs_path' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_get_underlying_path' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_ioctl_fd' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_isnumber' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_nicebytes' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_nicenum' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_nicenum_format' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_niceraw' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_nicetime' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_resolve_shortname' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_strcmp_pathname' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_strip_partition' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_strip_path' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_default_search_paths' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_dump_ddt' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_find_config' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_find_import_blkid' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_history_unpack' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_label_disk_wait' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_open_func' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_read_label' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_search_import' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zutil_alloc' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zutil_strdup' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	</elf-function-symbols>
	<elf-variable-symbols>
	<elf-symbol name='aok' size='4' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='buf' size='4110' type='tls-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='default_vtoc_map' size='64' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='efi_debug' size='4' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='pagesize' size='8' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	</elf-variable-symbols>
	- <abi-instr version='1.0' address-size='64' path='../../module/avl/avl.c' language='LANG_C89'>
	+ <abi-instr address-size='64' path='../../module/avl/avl.c' language='LANG_C99'>
	<function-decl name='avl_last' mangled-name='avl_last' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='avl_last'>
	<parameter type-id='a3681dea' name='tree'/>
	<return type-id='eaa32e2f'/>
	</function-decl>
	<function-decl name='avl_nearest' mangled-name='avl_nearest' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='avl_nearest'>
	<parameter type-id='a3681dea' name='tree'/>
	<parameter type-id='fba6cb51' name='where'/>
	<parameter type-id='95e97e5e' name='direction'/>
	<return type-id='eaa32e2f'/>
	</function-decl>
	<function-decl name='avl_insert_here' mangled-name='avl_insert_here' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='avl_insert_here'>
	<parameter type-id='a3681dea' name='tree'/>
	<parameter type-id='eaa32e2f' name='new_data'/>
	<parameter type-id='eaa32e2f' name='here'/>
	<parameter type-id='95e97e5e' name='direction'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='avl_add' mangled-name='avl_add' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='avl_add'>
	<parameter type-id='a3681dea' name='tree'/>
	<parameter type-id='eaa32e2f' name='new_node'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='avl_remove' mangled-name='avl_remove' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='avl_remove'>
	<parameter type-id='a3681dea' name='tree'/>
	<parameter type-id='eaa32e2f' name='data'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='avl_update_lt' mangled-name='avl_update_lt' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='avl_update_lt'>
	<parameter type-id='a3681dea' name='t'/>
	<parameter type-id='eaa32e2f' name='obj'/>
	<return type-id='c19b74c3'/>
	</function-decl>
	<function-decl name='avl_update_gt' mangled-name='avl_update_gt' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='avl_update_gt'>
	<parameter type-id='a3681dea' name='t'/>
	<parameter type-id='eaa32e2f' name='obj'/>
	<return type-id='c19b74c3'/>
	</function-decl>
	<function-decl name='avl_update' mangled-name='avl_update' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='avl_update'>
	<parameter type-id='a3681dea' name='t'/>
	<parameter type-id='eaa32e2f' name='obj'/>
	<return type-id='c19b74c3'/>
	</function-decl>
	<function-decl name='avl_swap' mangled-name='avl_swap' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='avl_swap'>
	<parameter type-id='a3681dea' name='tree1'/>
	<parameter type-id='a3681dea' name='tree2'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='avl_numnodes' mangled-name='avl_numnodes' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='avl_numnodes'>
	<parameter type-id='a3681dea' name='tree'/>
	<return type-id='ee1f298e'/>
	</function-decl>
	<function-decl name='avl_is_empty' mangled-name='avl_is_empty' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='avl_is_empty'>
	<parameter type-id='a3681dea' name='tree'/>
	<return type-id='c19b74c3'/>
	</function-decl>
	- <pointer-type-def type-id='f20fbd51' size-in-bits='64' id='a3681dea'/>
	- <type-decl name='int' size-in-bits='32' id='95e97e5e'/>
	- <typedef-decl name='avl_index_t' type-id='e475ab95' id='fba6cb51'/>
	- <typedef-decl name='boolean_t' type-id='08f5ca17' id='c19b74c3'/>
	- <typedef-decl name='ulong_t' type-id='7359adad' id='ee1f298e'/>
	- <type-decl name='void' id='48b5725f'/>
	- <pointer-type-def type-id='48b5725f' size-in-bits='64' id='eaa32e2f'/>
	- <enum-decl name='__anonymous_enum__' is-anonymous='yes' id='08f5ca17'>
	- <underlying-type type-id='9cac1fee'/>
	- <enumerator name='B_FALSE' value='0'/>
	- <enumerator name='B_TRUE' value='1'/>
	- </enum-decl>
	- <typedef-decl name='avl_tree_t' type-id='b351119f' id='f20fbd51'/>
	- <typedef-decl name='uintptr_t' type-id='7359adad' id='e475ab95'/>
	- <type-decl name='unsigned long int' size-in-bits='64' id='7359adad'/>
	- <class-decl name='avl_tree' size-in-bits='320' is-struct='yes' visibility='default' id='b351119f'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='avl_root' type-id='bf311473' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='avl_compar' type-id='585e1de9' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='avl_offset' type-id='b59d7dce' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='192'>
	- <var-decl name='avl_numnodes' type-id='ee1f298e' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='256'>
	- <var-decl name='avl_size' type-id='b59d7dce' visibility='default'/>
	- </data-member>
	- </class-decl>
	- <pointer-type-def type-id='428b67b3' size-in-bits='64' id='bf311473'/>
	- <pointer-type-def type-id='96ee24a5' size-in-bits='64' id='585e1de9'/>
	- <typedef-decl name='size_t' type-id='7359adad' id='b59d7dce'/>
	- <class-decl name='avl_node' size-in-bits='192' is-struct='yes' visibility='default' id='428b67b3'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='avl_child' type-id='f0f65199' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='avl_pcb' type-id='e475ab95' visibility='default'/>
	- </data-member>
	- </class-decl>
	- <array-type-def dimensions='1' type-id='bf311473' size-in-bits='128' id='f0f65199'>
	- <subrange length='2' type-id='4c87fef4' id='52efc4ef'/>
	- </array-type-def>
	- <type-decl name='sizetype' size-in-bits='64' id='4c87fef4'/>
	</abi-instr>
	- <abi-instr version='1.0' address-size='64' path='rdwr_efi.c' language='LANG_C89'>
	+ <abi-instr address-size='64' path='rdwr_efi.c' language='LANG_C99'>
	<array-type-def dimensions='1' type-id='72d5edd1' size-in-bits='512' id='c1dc88bc'>
	- <subrange length='16' type-id='4c87fef4' id='848d0938'/>
	+ <subrange length='16' type-id='7359adad' id='848d0938'/>
	</array-type-def>
	<class-decl name='dk_map2' size-in-bits='32' is-struct='yes' visibility='default' id='72d5edd1'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='p_tag' type-id='149c6638' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='16'>
	<var-decl name='p_flag' type-id='149c6638' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='uLong' type-id='7359adad' id='5bbcce85'/>
	- <typedef-decl name='Bytef' type-id='efb9ba06' id='c1606520'/>
	<typedef-decl name='Byte' type-id='002ac4a6' id='efb9ba06'/>
	<typedef-decl name='uInt' type-id='f0981eeb' id='09110a74'/>
	+ <typedef-decl name='uLong' type-id='7359adad' id='5bbcce85'/>
	+ <typedef-decl name='Bytef' type-id='efb9ba06' id='c1606520'/>
	<qualified-type-def type-id='c1606520' const='yes' id='a6124a50'/>
	<pointer-type-def type-id='a6124a50' size-in-bits='64' id='e8cb3e0e'/>
	<qualified-type-def type-id='002ac4a6' const='yes' id='ea86de29'/>
	<pointer-type-def type-id='ea86de29' size-in-bits='64' id='354f7eb9'/>
	<pointer-type-def type-id='002ac4a6' size-in-bits='64' id='cf536864'/>
	+ <var-decl name='default_vtoc_map' type-id='c1dc88bc' mangled-name='default_vtoc_map' visibility='default' elf-symbol-id='default_vtoc_map'/>
	+ <var-decl name='efi_debug' type-id='95e97e5e' mangled-name='efi_debug' visibility='default' elf-symbol-id='efi_debug'/>
	<function-decl name='efi_alloc_and_read' mangled-name='efi_alloc_and_read' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='efi_alloc_and_read'>
	<parameter type-id='95e97e5e' name='fd'/>
	<parameter type-id='c43b27a6' name='vtoc'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='efi_rescan' mangled-name='efi_rescan' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='efi_rescan'>
	<parameter type-id='95e97e5e' name='fd'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='efi_write' mangled-name='efi_write' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='efi_write'>
	+ <function-decl name='efi_use_whole_disk' mangled-name='efi_use_whole_disk' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='efi_use_whole_disk'>
	<parameter type-id='95e97e5e' name='fd'/>
	- <parameter type-id='0d8119a8' name='vtoc'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='efi_use_whole_disk' mangled-name='efi_use_whole_disk' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='efi_use_whole_disk'>
	+ <function-decl name='efi_write' mangled-name='efi_write' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='efi_write'>
	<parameter type-id='95e97e5e' name='fd'/>
	+ <parameter type-id='0d8119a8' name='vtoc'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='efi_type' mangled-name='efi_type' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='efi_type'>
	<parameter type-id='95e97e5e' name='fd'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='efi_err_check' mangled-name='efi_err_check' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='efi_err_check'>
	<parameter type-id='0d8119a8' name='vtoc'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='efi_auto_sense' mangled-name='efi_auto_sense' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='efi_auto_sense'>
	<parameter type-id='95e97e5e' name='fd'/>
	<parameter type-id='c43b27a6' name='vtoc'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <var-decl name='default_vtoc_map' type-id='c1dc88bc' mangled-name='default_vtoc_map' visibility='default' elf-symbol-id='default_vtoc_map'/>
	- <var-decl name='efi_debug' type-id='95e97e5e' mangled-name='efi_debug' visibility='default' elf-symbol-id='efi_debug'/>
	<function-decl name='sprintf' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='26a90f95'/>
	<parameter type-id='80f4b756'/>
	<parameter is-variadic='yes'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='write' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='95e97e5e'/>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='b59d7dce'/>
	<return type-id='79a0948f'/>
	</function-decl>
	<function-decl name='fsync' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='95e97e5e'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='crc32' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='5bbcce85'/>
	- <parameter type-id='e8cb3e0e'/>
	- <parameter type-id='09110a74'/>
	- <return type-id='5bbcce85'/>
	- </function-decl>
	- <function-decl name='bcmp' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='eaa32e2f'/>
	- <parameter type-id='eaa32e2f'/>
	- <parameter type-id='b59d7dce'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	<function-decl name='uuid_generate' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='cf536864'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='uuid_is_null' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='354f7eb9'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='bcopy' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='eaa32e2f'/>
	- <parameter type-id='eaa32e2f'/>
	- <parameter type-id='b59d7dce'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	- <pointer-type-def type-id='a84c031d' size-in-bits='64' id='26a90f95'/>
	- <pointer-type-def type-id='9b45d938' size-in-bits='64' id='80f4b756'/>
	- <pointer-type-def type-id='dd4a2e5a' size-in-bits='64' id='0d8119a8'/>
	- <pointer-type-def type-id='0d8119a8' size-in-bits='64' id='c43b27a6'/>
	- <typedef-decl name='ssize_t' type-id='41060289' id='79a0948f'/>
	- <typedef-decl name='uint16_t' type-id='8efea9e5' id='149c6638'/>
	- <type-decl name='unsigned char' size-in-bits='8' id='002ac4a6'/>
	- <type-decl name='unsigned int' size-in-bits='32' id='f0981eeb'/>
	- <type-decl name='char' size-in-bits='8' id='a84c031d'/>
	- <class-decl name='dk_gpt' size-in-bits='1920' is-struct='yes' visibility='default' id='dd4a2e5a'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='efi_version' type-id='3502e3ff' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='32'>
	- <var-decl name='efi_nparts' type-id='3502e3ff' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='efi_part_size' type-id='3502e3ff' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='96'>
	- <var-decl name='efi_lbasize' type-id='3502e3ff' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='efi_last_lba' type-id='804dc465' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='192'>
	- <var-decl name='efi_first_u_lba' type-id='804dc465' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='256'>
	- <var-decl name='efi_last_u_lba' type-id='804dc465' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='320'>
	- <var-decl name='efi_disk_uguid' type-id='214f32ea' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='448'>
	- <var-decl name='efi_flags' type-id='3502e3ff' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='480'>
	- <var-decl name='efi_reserved1' type-id='3502e3ff' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='512'>
	- <var-decl name='efi_altern_lba' type-id='804dc465' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='576'>
	- <var-decl name='efi_reserved' type-id='dba89ba3' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='960'>
	- <var-decl name='efi_parts' type-id='fa198beb' visibility='default'/>
	- </data-member>
	- </class-decl>
	- <qualified-type-def type-id='a84c031d' const='yes' id='9b45d938'/>
	- <typedef-decl name='__ssize_t' type-id='bd54fe1a' id='41060289'/>
	- <type-decl name='unsigned short int' size-in-bits='16' id='8efea9e5'/>
	- <class-decl name='uuid' size-in-bits='128' is-struct='yes' visibility='default' id='214f32ea'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='time_low' type-id='8f92235e' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='32'>
	- <var-decl name='time_mid' type-id='149c6638' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='48'>
	- <var-decl name='time_hi_and_version' type-id='149c6638' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='clock_seq_hi_and_reserved' type-id='b96825af' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='72'>
	- <var-decl name='clock_seq_low' type-id='b96825af' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='80'>
	- <var-decl name='node_addr' type-id='0f562bd0' visibility='default'/>
	- </data-member>
	- </class-decl>
	- <array-type-def dimensions='1' type-id='a65ae39c' size-in-bits='960' id='fa198beb'>
	- <subrange length='1' type-id='4c87fef4' id='52f813b4'/>
	- </array-type-def>
	- <type-decl name='long int' size-in-bits='64' id='bd54fe1a'/>
	- <typedef-decl name='diskaddr_t' type-id='9b3ff54f' id='804dc465'/>
	- <typedef-decl name='uint_t' type-id='f0981eeb' id='3502e3ff'/>
	- <array-type-def dimensions='1' type-id='3502e3ff' size-in-bits='384' id='dba89ba3'>
	- <subrange length='12' type-id='4c87fef4' id='84827bdc'/>
	- </array-type-def>
	- <class-decl name='dk_part' size-in-bits='960' is-struct='yes' visibility='default' id='a65ae39c'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='p_start' type-id='804dc465' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='p_size' type-id='804dc465' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='p_guid' type-id='214f32ea' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='256'>
	- <var-decl name='p_tag' type-id='d908a348' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='272'>
	- <var-decl name='p_flag' type-id='d908a348' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='288'>
	- <var-decl name='p_name' type-id='16e6f2c6' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='576'>
	- <var-decl name='p_uguid' type-id='214f32ea' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='704'>
	- <var-decl name='p_resv' type-id='01d84ed4' visibility='default'/>
	- </data-member>
	- </class-decl>
	- <typedef-decl name='longlong_t' type-id='1eb56b1e' id='9b3ff54f'/>
	- <typedef-decl name='uint32_t' type-id='f0981eeb' id='8f92235e'/>
	- <typedef-decl name='uint8_t' type-id='002ac4a6' id='b96825af'/>
	- <array-type-def dimensions='1' type-id='b96825af' size-in-bits='48' id='0f562bd0'>
	- <subrange length='6' type-id='4c87fef4' id='52fa524b'/>
	- </array-type-def>
	- <array-type-def dimensions='1' type-id='a84c031d' size-in-bits='288' id='16e6f2c6'>
	- <subrange length='36' type-id='4c87fef4' id='ae666bde'/>
	- </array-type-def>
	- <type-decl name='long long int' size-in-bits='64' id='1eb56b1e'/>
	- <typedef-decl name='ushort_t' type-id='8efea9e5' id='d908a348'/>
	- <array-type-def dimensions='1' type-id='3502e3ff' size-in-bits='256' id='01d84ed4'>
	- <subrange length='8' type-id='4c87fef4' id='56e0c0b1'/>
	- </array-type-def>
	- </abi-instr>
	- <abi-instr version='1.0' address-size='64' path='assert.c' language='LANG_C89'>
	- <var-decl name='aok' type-id='95e97e5e' mangled-name='aok' visibility='default' elf-symbol-id='aok'/>
	- <function-decl name='vfprintf' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='822cd80b'/>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='b7f2d5e6'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='abort' visibility='default' binding='global' size-in-bits='64'>
	- <return type-id='48b5725f'/>
	- </function-decl>
	- <pointer-type-def type-id='aa12d1ba' size-in-bits='64' id='822cd80b'/>
	- <pointer-type-def type-id='d5027220' size-in-bits='64' id='b7f2d5e6'/>
	- <class-decl name='__va_list_tag' size-in-bits='192' is-struct='yes' visibility='default' id='d5027220'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='gp_offset' type-id='f0981eeb' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='32'>
	- <var-decl name='fp_offset' type-id='f0981eeb' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='overflow_arg_area' type-id='eaa32e2f' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='reg_save_area' type-id='eaa32e2f' visibility='default'/>
	- </data-member>
	- </class-decl>
	- <typedef-decl name='FILE' type-id='ec1ed955' id='aa12d1ba'/>
	- <class-decl name='_IO_FILE' size-in-bits='1728' is-struct='yes' visibility='default' id='ec1ed955'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='_flags' type-id='95e97e5e' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='_IO_read_ptr' type-id='26a90f95' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='_IO_read_end' type-id='26a90f95' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='192'>
	- <var-decl name='_IO_read_base' type-id='26a90f95' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='256'>
	- <var-decl name='_IO_write_base' type-id='26a90f95' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='320'>
	- <var-decl name='_IO_write_ptr' type-id='26a90f95' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='384'>
	- <var-decl name='_IO_write_end' type-id='26a90f95' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='448'>
	- <var-decl name='_IO_buf_base' type-id='26a90f95' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='512'>
	- <var-decl name='_IO_buf_end' type-id='26a90f95' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='576'>
	- <var-decl name='_IO_save_base' type-id='26a90f95' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='640'>
	- <var-decl name='_IO_backup_base' type-id='26a90f95' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='704'>
	- <var-decl name='_IO_save_end' type-id='26a90f95' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='768'>
	- <var-decl name='_markers' type-id='e4c6fa61' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='832'>
	- <var-decl name='_chain' type-id='dca988a5' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='896'>
	- <var-decl name='_fileno' type-id='95e97e5e' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='928'>
	- <var-decl name='_flags2' type-id='95e97e5e' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='960'>
	- <var-decl name='_old_offset' type-id='79989e9c' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='1024'>
	- <var-decl name='_cur_column' type-id='8efea9e5' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='1040'>
	- <var-decl name='_vtable_offset' type-id='28577a57' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='1048'>
	- <var-decl name='_shortbuf' type-id='89feb1ec' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='1088'>
	- <var-decl name='_lock' type-id='cecf4ea7' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='1152'>
	- <var-decl name='_offset' type-id='724e4de6' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='1216'>
	- <var-decl name='__pad1' type-id='eaa32e2f' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='1280'>
	- <var-decl name='__pad2' type-id='eaa32e2f' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='1344'>
	- <var-decl name='__pad3' type-id='eaa32e2f' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='1408'>
	- <var-decl name='__pad4' type-id='eaa32e2f' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='1472'>
	- <var-decl name='__pad5' type-id='b59d7dce' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='1536'>
	- <var-decl name='_mode' type-id='95e97e5e' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='1568'>
	- <var-decl name='_unused2' type-id='664ac0b7' visibility='default'/>
	- </data-member>
	- </class-decl>
	- <pointer-type-def type-id='ec1ed955' size-in-bits='64' id='dca988a5'/>
	- <pointer-type-def type-id='bb4788fa' size-in-bits='64' id='cecf4ea7'/>
	- <pointer-type-def type-id='010ae0b9' size-in-bits='64' id='e4c6fa61'/>
	- <array-type-def dimensions='1' type-id='a84c031d' size-in-bits='8' id='89feb1ec'>
	- <subrange length='1' type-id='4c87fef4' id='52f813b4'/>
	- </array-type-def>
	- <array-type-def dimensions='1' type-id='a84c031d' size-in-bits='160' id='664ac0b7'>
	- <subrange length='20' type-id='4c87fef4' id='fdca39cf'/>
	- </array-type-def>
	- <type-decl name='signed char' size-in-bits='8' id='28577a57'/>
	- <typedef-decl name='__off64_t' type-id='bd54fe1a' id='724e4de6'/>
	- <typedef-decl name='__off_t' type-id='bd54fe1a' id='79989e9c'/>
	- <class-decl name='_IO_marker' size-in-bits='192' is-struct='yes' visibility='default' id='010ae0b9'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='_next' type-id='e4c6fa61' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='_sbuf' type-id='dca988a5' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='_pos' type-id='95e97e5e' visibility='default'/>
	- </data-member>
	- </class-decl>
	- <typedef-decl name='_IO_lock_t' type-id='48b5725f' id='bb4788fa'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='crc32' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='5bbcce85'/>
	+ <parameter type-id='e8cb3e0e'/>
	+ <parameter type-id='09110a74'/>
	+ <return type-id='5bbcce85'/>
	+ </function-decl>
	+ <type-decl name='unsigned long int' size-in-bits='64' id='7359adad'/>
	+ </abi-instr>
	+ <abi-instr address-size='64' path='assert.c' language='LANG_C99'>
	+ <var-decl name='aok' type-id='95e97e5e' mangled-name='aok' visibility='default' elf-symbol-id='aok'/>
	+ <function-decl name='vfprintf' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='e75a27e9'/>
	+ <parameter type-id='9d26089a'/>
	+ <parameter type-id='b7f2d5e6'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='abort' visibility='default' binding='global' size-in-bits='64'>
	+ <return type-id='48b5725f'/>
	+ </function-decl>
	</abi-instr>
	- <abi-instr version='1.0' address-size='64' path='atomic.c' language='LANG_C89'>
	- <typedef-decl name='int8_t' type-id='28577a57' id='ee31ee44'/>
	- <typedef-decl name='int64_t' type-id='bd54fe1a' id='9da381c4'/>
	- <qualified-type-def type-id='d8bf0010' volatile='yes' id='b867ca41'/>
	- <pointer-type-def type-id='b867ca41' size-in-bits='64' id='b663a671'/>
	+ <abi-instr address-size='64' path='atomic.c' language='LANG_C99'>
	+ <typedef-decl name='int8_t' type-id='2171a512' id='ee31ee44'/>
	+ <typedef-decl name='__int8_t' type-id='28577a57' id='2171a512'/>
	<qualified-type-def type-id='149c6638' volatile='yes' id='5120c5f7'/>
	<pointer-type-def type-id='5120c5f7' size-in-bits='64' id='93977ae7'/>
	<qualified-type-def type-id='8f92235e' volatile='yes' id='430e0681'/>
	<pointer-type-def type-id='430e0681' size-in-bits='64' id='3a147f31'/>
	- <qualified-type-def type-id='9c313c2d' volatile='yes' id='4f4abd5e'/>
	- <pointer-type-def type-id='4f4abd5e' size-in-bits='64' id='46a83d9c'/>
	<qualified-type-def type-id='b96825af' volatile='yes' id='84ff7d66'/>
	<pointer-type-def type-id='84ff7d66' size-in-bits='64' id='aa323ea4'/>
	- <qualified-type-def type-id='3502e3ff' volatile='yes' id='d0290e74'/>
	- <pointer-type-def type-id='d0290e74' size-in-bits='64' id='0ea19dfa'/>
	<qualified-type-def type-id='ee1f298e' volatile='yes' id='6f7e09cb'/>
	<pointer-type-def type-id='6f7e09cb' size-in-bits='64' id='64698d33'/>
	- <qualified-type-def type-id='d908a348' volatile='yes' id='65d4726b'/>
	- <pointer-type-def type-id='65d4726b' size-in-bits='64' id='8e6fdc53'/>
	<function-decl name='atomic_inc_8' mangled-name='atomic_inc_8' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_inc_8'>
	<parameter type-id='aa323ea4' name='target'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='atomic_inc_uchar' mangled-name='atomic_inc_uchar' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_inc_uchar'>
	- <parameter type-id='b663a671' name='target'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	<function-decl name='atomic_inc_16' mangled-name='atomic_inc_16' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_inc_16'>
	<parameter type-id='93977ae7' name='target'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='atomic_inc_ushort' mangled-name='atomic_inc_ushort' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_inc_ushort'>
	- <parameter type-id='8e6fdc53' name='target'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	<function-decl name='atomic_inc_32' mangled-name='atomic_inc_32' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_inc_32'>
	<parameter type-id='3a147f31' name='target'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='atomic_inc_uint' mangled-name='atomic_inc_uint' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_inc_uint'>
	- <parameter type-id='0ea19dfa' name='target'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	<function-decl name='atomic_inc_ulong' mangled-name='atomic_inc_ulong' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_inc_ulong'>
	<parameter type-id='64698d33' name='target'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='atomic_inc_64' mangled-name='atomic_inc_64' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_inc_64'>
	- <parameter type-id='46a83d9c' name='target'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	<function-decl name='atomic_dec_8' mangled-name='atomic_dec_8' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_dec_8'>
	<parameter type-id='aa323ea4' name='target'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='atomic_dec_uchar' mangled-name='atomic_dec_uchar' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_dec_uchar'>
	- <parameter type-id='b663a671' name='target'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	<function-decl name='atomic_dec_16' mangled-name='atomic_dec_16' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_dec_16'>
	<parameter type-id='93977ae7' name='target'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='atomic_dec_ushort' mangled-name='atomic_dec_ushort' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_dec_ushort'>
	- <parameter type-id='8e6fdc53' name='target'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	<function-decl name='atomic_dec_32' mangled-name='atomic_dec_32' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_dec_32'>
	<parameter type-id='3a147f31' name='target'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='atomic_dec_uint' mangled-name='atomic_dec_uint' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_dec_uint'>
	- <parameter type-id='0ea19dfa' name='target'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	<function-decl name='atomic_dec_ulong' mangled-name='atomic_dec_ulong' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_dec_ulong'>
	<parameter type-id='64698d33' name='target'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='atomic_dec_64' mangled-name='atomic_dec_64' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_dec_64'>
	- <parameter type-id='46a83d9c' name='target'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	<function-decl name='atomic_add_8' mangled-name='atomic_add_8' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_add_8'>
	<parameter type-id='aa323ea4' name='target'/>
	<parameter type-id='ee31ee44' name='bits'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='atomic_add_char' mangled-name='atomic_add_char' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_add_char'>
	- <parameter type-id='b663a671' name='target'/>
	- <parameter type-id='28577a57' name='bits'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	<function-decl name='atomic_add_16' mangled-name='atomic_add_16' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_add_16'>
	<parameter type-id='93977ae7' name='target'/>
	<parameter type-id='23bd8cb5' name='bits'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='atomic_add_short' mangled-name='atomic_add_short' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_add_short'>
	- <parameter type-id='8e6fdc53' name='target'/>
	- <parameter type-id='a2185560' name='bits'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	<function-decl name='atomic_add_32' mangled-name='atomic_add_32' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_add_32'>
	<parameter type-id='3a147f31' name='target'/>
	<parameter type-id='3ff5601b' name='bits'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='atomic_add_int' mangled-name='atomic_add_int' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_add_int'>
	- <parameter type-id='0ea19dfa' name='target'/>
	- <parameter type-id='95e97e5e' name='bits'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	- <function-decl name='atomic_add_long' mangled-name='atomic_add_long' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_add_long'>
	- <parameter type-id='64698d33' name='target'/>
	- <parameter type-id='bd54fe1a' name='bits'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	- <function-decl name='atomic_add_64' mangled-name='atomic_add_64' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_add_64'>
	- <parameter type-id='46a83d9c' name='target'/>
	- <parameter type-id='9da381c4' name='bits'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	<function-decl name='atomic_add_ptr' mangled-name='atomic_add_ptr' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_add_ptr'>
	<parameter type-id='fe09dd29' name='target'/>
	<parameter type-id='79a0948f' name='bits'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='atomic_sub_8' mangled-name='atomic_sub_8' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_sub_8'>
	<parameter type-id='aa323ea4' name='target'/>
	<parameter type-id='ee31ee44' name='bits'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='atomic_sub_char' mangled-name='atomic_sub_char' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_sub_char'>
	- <parameter type-id='b663a671' name='target'/>
	- <parameter type-id='28577a57' name='bits'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	<function-decl name='atomic_sub_16' mangled-name='atomic_sub_16' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_sub_16'>
	<parameter type-id='93977ae7' name='target'/>
	<parameter type-id='23bd8cb5' name='bits'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='atomic_sub_short' mangled-name='atomic_sub_short' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_sub_short'>
	- <parameter type-id='8e6fdc53' name='target'/>
	- <parameter type-id='a2185560' name='bits'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	<function-decl name='atomic_sub_32' mangled-name='atomic_sub_32' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_sub_32'>
	<parameter type-id='3a147f31' name='target'/>
	<parameter type-id='3ff5601b' name='bits'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='atomic_sub_int' mangled-name='atomic_sub_int' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_sub_int'>
	- <parameter type-id='0ea19dfa' name='target'/>
	- <parameter type-id='95e97e5e' name='bits'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	- <function-decl name='atomic_sub_long' mangled-name='atomic_sub_long' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_sub_long'>
	- <parameter type-id='64698d33' name='target'/>
	- <parameter type-id='bd54fe1a' name='bits'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	- <function-decl name='atomic_sub_64' mangled-name='atomic_sub_64' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_sub_64'>
	- <parameter type-id='46a83d9c' name='target'/>
	- <parameter type-id='9da381c4' name='bits'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	<function-decl name='atomic_sub_ptr' mangled-name='atomic_sub_ptr' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_sub_ptr'>
	<parameter type-id='fe09dd29' name='target'/>
	<parameter type-id='79a0948f' name='bits'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='atomic_or_8' mangled-name='atomic_or_8' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_or_8'>
	<parameter type-id='aa323ea4' name='target'/>
	<parameter type-id='b96825af' name='bits'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='atomic_or_uchar' mangled-name='atomic_or_uchar' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_or_uchar'>
	- <parameter type-id='b663a671' name='target'/>
	- <parameter type-id='d8bf0010' name='bits'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	<function-decl name='atomic_or_16' mangled-name='atomic_or_16' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_or_16'>
	<parameter type-id='93977ae7' name='target'/>
	<parameter type-id='149c6638' name='bits'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='atomic_or_ushort' mangled-name='atomic_or_ushort' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_or_ushort'>
	- <parameter type-id='8e6fdc53' name='target'/>
	- <parameter type-id='d908a348' name='bits'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	<function-decl name='atomic_or_32' mangled-name='atomic_or_32' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_or_32'>
	<parameter type-id='3a147f31' name='target'/>
	<parameter type-id='8f92235e' name='bits'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='atomic_or_uint' mangled-name='atomic_or_uint' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_or_uint'>
	- <parameter type-id='0ea19dfa' name='target'/>
	- <parameter type-id='3502e3ff' name='bits'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	<function-decl name='atomic_or_ulong' mangled-name='atomic_or_ulong' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_or_ulong'>
	<parameter type-id='64698d33' name='target'/>
	<parameter type-id='ee1f298e' name='bits'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='atomic_or_64' mangled-name='atomic_or_64' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_or_64'>
	- <parameter type-id='46a83d9c' name='target'/>
	- <parameter type-id='9c313c2d' name='bits'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	<function-decl name='atomic_and_8' mangled-name='atomic_and_8' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_and_8'>
	<parameter type-id='aa323ea4' name='target'/>
	<parameter type-id='b96825af' name='bits'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='atomic_and_uchar' mangled-name='atomic_and_uchar' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_and_uchar'>
	- <parameter type-id='b663a671' name='target'/>
	- <parameter type-id='d8bf0010' name='bits'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	<function-decl name='atomic_and_16' mangled-name='atomic_and_16' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_and_16'>
	<parameter type-id='93977ae7' name='target'/>
	<parameter type-id='149c6638' name='bits'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='atomic_and_ushort' mangled-name='atomic_and_ushort' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_and_ushort'>
	- <parameter type-id='8e6fdc53' name='target'/>
	- <parameter type-id='d908a348' name='bits'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	<function-decl name='atomic_and_32' mangled-name='atomic_and_32' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_and_32'>
	<parameter type-id='3a147f31' name='target'/>
	<parameter type-id='8f92235e' name='bits'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='atomic_and_uint' mangled-name='atomic_and_uint' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_and_uint'>
	- <parameter type-id='0ea19dfa' name='target'/>
	- <parameter type-id='3502e3ff' name='bits'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	<function-decl name='atomic_and_ulong' mangled-name='atomic_and_ulong' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_and_ulong'>
	<parameter type-id='64698d33' name='target'/>
	<parameter type-id='ee1f298e' name='bits'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='atomic_and_64' mangled-name='atomic_and_64' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_and_64'>
	- <parameter type-id='46a83d9c' name='target'/>
	- <parameter type-id='9c313c2d' name='bits'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	<function-decl name='atomic_inc_8_nv' mangled-name='atomic_inc_8_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_inc_8_nv'>
	<parameter type-id='aa323ea4' name='target'/>
	<return type-id='b96825af'/>
	</function-decl>
	- <function-decl name='atomic_inc_uchar_nv' mangled-name='atomic_inc_uchar_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_inc_uchar_nv'>
	- <parameter type-id='b663a671' name='target'/>
	- <return type-id='d8bf0010'/>
	- </function-decl>
	<function-decl name='atomic_inc_16_nv' mangled-name='atomic_inc_16_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_inc_16_nv'>
	<parameter type-id='93977ae7' name='target'/>
	<return type-id='149c6638'/>
	</function-decl>
	- <function-decl name='atomic_inc_ushort_nv' mangled-name='atomic_inc_ushort_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_inc_ushort_nv'>
	- <parameter type-id='8e6fdc53' name='target'/>
	- <return type-id='d908a348'/>
	- </function-decl>
	<function-decl name='atomic_inc_32_nv' mangled-name='atomic_inc_32_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_inc_32_nv'>
	<parameter type-id='3a147f31' name='target'/>
	<return type-id='8f92235e'/>
	</function-decl>
	- <function-decl name='atomic_inc_uint_nv' mangled-name='atomic_inc_uint_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_inc_uint_nv'>
	- <parameter type-id='0ea19dfa' name='target'/>
	- <return type-id='3502e3ff'/>
	- </function-decl>
	<function-decl name='atomic_inc_ulong_nv' mangled-name='atomic_inc_ulong_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_inc_ulong_nv'>
	<parameter type-id='64698d33' name='target'/>
	<return type-id='ee1f298e'/>
	</function-decl>
	- <function-decl name='atomic_inc_64_nv' mangled-name='atomic_inc_64_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_inc_64_nv'>
	- <parameter type-id='46a83d9c' name='target'/>
	- <return type-id='9c313c2d'/>
	- </function-decl>
	<function-decl name='atomic_dec_8_nv' mangled-name='atomic_dec_8_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_dec_8_nv'>
	<parameter type-id='aa323ea4' name='target'/>
	<return type-id='b96825af'/>
	</function-decl>
	- <function-decl name='atomic_dec_uchar_nv' mangled-name='atomic_dec_uchar_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_dec_uchar_nv'>
	- <parameter type-id='b663a671' name='target'/>
	- <return type-id='d8bf0010'/>
	- </function-decl>
	<function-decl name='atomic_dec_16_nv' mangled-name='atomic_dec_16_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_dec_16_nv'>
	<parameter type-id='93977ae7' name='target'/>
	<return type-id='149c6638'/>
	</function-decl>
	- <function-decl name='atomic_dec_ushort_nv' mangled-name='atomic_dec_ushort_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_dec_ushort_nv'>
	- <parameter type-id='8e6fdc53' name='target'/>
	- <return type-id='d908a348'/>
	- </function-decl>
	<function-decl name='atomic_dec_32_nv' mangled-name='atomic_dec_32_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_dec_32_nv'>
	<parameter type-id='3a147f31' name='target'/>
	<return type-id='8f92235e'/>
	</function-decl>
	- <function-decl name='atomic_dec_uint_nv' mangled-name='atomic_dec_uint_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_dec_uint_nv'>
	- <parameter type-id='0ea19dfa' name='target'/>
	- <return type-id='3502e3ff'/>
	- </function-decl>
	<function-decl name='atomic_dec_ulong_nv' mangled-name='atomic_dec_ulong_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_dec_ulong_nv'>
	<parameter type-id='64698d33' name='target'/>
	<return type-id='ee1f298e'/>
	</function-decl>
	- <function-decl name='atomic_dec_64_nv' mangled-name='atomic_dec_64_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_dec_64_nv'>
	- <parameter type-id='46a83d9c' name='target'/>
	- <return type-id='9c313c2d'/>
	- </function-decl>
	<function-decl name='atomic_add_8_nv' mangled-name='atomic_add_8_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_add_8_nv'>
	<parameter type-id='aa323ea4' name='target'/>
	<parameter type-id='ee31ee44' name='bits'/>
	<return type-id='b96825af'/>
	</function-decl>
	- <function-decl name='atomic_add_char_nv' mangled-name='atomic_add_char_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_add_char_nv'>
	- <parameter type-id='b663a671' name='target'/>
	- <parameter type-id='28577a57' name='bits'/>
	- <return type-id='d8bf0010'/>
	- </function-decl>
	<function-decl name='atomic_add_16_nv' mangled-name='atomic_add_16_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_add_16_nv'>
	<parameter type-id='93977ae7' name='target'/>
	<parameter type-id='23bd8cb5' name='bits'/>
	<return type-id='149c6638'/>
	</function-decl>
	- <function-decl name='atomic_add_short_nv' mangled-name='atomic_add_short_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_add_short_nv'>
	- <parameter type-id='8e6fdc53' name='target'/>
	- <parameter type-id='a2185560' name='bits'/>
	- <return type-id='d908a348'/>
	- </function-decl>
	<function-decl name='atomic_add_32_nv' mangled-name='atomic_add_32_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_add_32_nv'>
	<parameter type-id='3a147f31' name='target'/>
	<parameter type-id='3ff5601b' name='bits'/>
	<return type-id='8f92235e'/>
	</function-decl>
	- <function-decl name='atomic_add_int_nv' mangled-name='atomic_add_int_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_add_int_nv'>
	- <parameter type-id='0ea19dfa' name='target'/>
	- <parameter type-id='95e97e5e' name='bits'/>
	- <return type-id='3502e3ff'/>
	- </function-decl>
	<function-decl name='atomic_add_long_nv' mangled-name='atomic_add_long_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_add_long_nv'>
	<parameter type-id='64698d33' name='target'/>
	<parameter type-id='bd54fe1a' name='bits'/>
	<return type-id='ee1f298e'/>
	</function-decl>
	- <function-decl name='atomic_add_64_nv' mangled-name='atomic_add_64_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_add_64_nv'>
	- <parameter type-id='46a83d9c' name='target'/>
	- <parameter type-id='9da381c4' name='bits'/>
	- <return type-id='9c313c2d'/>
	- </function-decl>
	<function-decl name='atomic_add_ptr_nv' mangled-name='atomic_add_ptr_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_add_ptr_nv'>
	<parameter type-id='fe09dd29' name='target'/>
	<parameter type-id='79a0948f' name='bits'/>
	<return type-id='eaa32e2f'/>
	</function-decl>
	<function-decl name='atomic_sub_8_nv' mangled-name='atomic_sub_8_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_sub_8_nv'>
	<parameter type-id='aa323ea4' name='target'/>
	<parameter type-id='ee31ee44' name='bits'/>
	<return type-id='b96825af'/>
	</function-decl>
	- <function-decl name='atomic_sub_char_nv' mangled-name='atomic_sub_char_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_sub_char_nv'>
	- <parameter type-id='b663a671' name='target'/>
	- <parameter type-id='28577a57' name='bits'/>
	- <return type-id='d8bf0010'/>
	- </function-decl>
	<function-decl name='atomic_sub_16_nv' mangled-name='atomic_sub_16_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_sub_16_nv'>
	<parameter type-id='93977ae7' name='target'/>
	<parameter type-id='23bd8cb5' name='bits'/>
	<return type-id='149c6638'/>
	</function-decl>
	- <function-decl name='atomic_sub_short_nv' mangled-name='atomic_sub_short_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_sub_short_nv'>
	- <parameter type-id='8e6fdc53' name='target'/>
	- <parameter type-id='a2185560' name='bits'/>
	- <return type-id='d908a348'/>
	- </function-decl>
	<function-decl name='atomic_sub_32_nv' mangled-name='atomic_sub_32_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_sub_32_nv'>
	<parameter type-id='3a147f31' name='target'/>
	<parameter type-id='3ff5601b' name='bits'/>
	<return type-id='8f92235e'/>
	</function-decl>
	- <function-decl name='atomic_sub_int_nv' mangled-name='atomic_sub_int_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_sub_int_nv'>
	- <parameter type-id='0ea19dfa' name='target'/>
	- <parameter type-id='95e97e5e' name='bits'/>
	- <return type-id='3502e3ff'/>
	- </function-decl>
	<function-decl name='atomic_sub_long_nv' mangled-name='atomic_sub_long_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_sub_long_nv'>
	<parameter type-id='64698d33' name='target'/>
	<parameter type-id='bd54fe1a' name='bits'/>
	<return type-id='ee1f298e'/>
	</function-decl>
	- <function-decl name='atomic_sub_64_nv' mangled-name='atomic_sub_64_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_sub_64_nv'>
	- <parameter type-id='46a83d9c' name='target'/>
	- <parameter type-id='9da381c4' name='bits'/>
	- <return type-id='9c313c2d'/>
	- </function-decl>
	<function-decl name='atomic_sub_ptr_nv' mangled-name='atomic_sub_ptr_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_sub_ptr_nv'>
	<parameter type-id='fe09dd29' name='target'/>
	<parameter type-id='79a0948f' name='bits'/>
	<return type-id='eaa32e2f'/>
	</function-decl>
	<function-decl name='atomic_or_8_nv' mangled-name='atomic_or_8_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_or_8_nv'>
	<parameter type-id='aa323ea4' name='target'/>
	<parameter type-id='b96825af' name='bits'/>
	<return type-id='b96825af'/>
	</function-decl>
	- <function-decl name='atomic_or_uchar_nv' mangled-name='atomic_or_uchar_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_or_uchar_nv'>
	- <parameter type-id='b663a671' name='target'/>
	- <parameter type-id='d8bf0010' name='bits'/>
	- <return type-id='d8bf0010'/>
	- </function-decl>
	<function-decl name='atomic_or_16_nv' mangled-name='atomic_or_16_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_or_16_nv'>
	<parameter type-id='93977ae7' name='target'/>
	<parameter type-id='149c6638' name='bits'/>
	<return type-id='149c6638'/>
	</function-decl>
	- <function-decl name='atomic_or_ushort_nv' mangled-name='atomic_or_ushort_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_or_ushort_nv'>
	- <parameter type-id='8e6fdc53' name='target'/>
	- <parameter type-id='d908a348' name='bits'/>
	- <return type-id='d908a348'/>
	- </function-decl>
	<function-decl name='atomic_or_32_nv' mangled-name='atomic_or_32_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_or_32_nv'>
	<parameter type-id='3a147f31' name='target'/>
	<parameter type-id='8f92235e' name='bits'/>
	<return type-id='8f92235e'/>
	</function-decl>
	- <function-decl name='atomic_or_uint_nv' mangled-name='atomic_or_uint_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_or_uint_nv'>
	- <parameter type-id='0ea19dfa' name='target'/>
	- <parameter type-id='3502e3ff' name='bits'/>
	- <return type-id='3502e3ff'/>
	- </function-decl>
	<function-decl name='atomic_or_ulong_nv' mangled-name='atomic_or_ulong_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_or_ulong_nv'>
	<parameter type-id='64698d33' name='target'/>
	<parameter type-id='ee1f298e' name='bits'/>
	<return type-id='ee1f298e'/>
	</function-decl>
	- <function-decl name='atomic_or_64_nv' mangled-name='atomic_or_64_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_or_64_nv'>
	- <parameter type-id='46a83d9c' name='target'/>
	- <parameter type-id='9c313c2d' name='bits'/>
	- <return type-id='9c313c2d'/>
	- </function-decl>
	<function-decl name='atomic_and_8_nv' mangled-name='atomic_and_8_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_and_8_nv'>
	<parameter type-id='aa323ea4' name='target'/>
	<parameter type-id='b96825af' name='bits'/>
	<return type-id='b96825af'/>
	</function-decl>
	- <function-decl name='atomic_and_uchar_nv' mangled-name='atomic_and_uchar_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_and_uchar_nv'>
	- <parameter type-id='b663a671' name='target'/>
	- <parameter type-id='d8bf0010' name='bits'/>
	- <return type-id='d8bf0010'/>
	- </function-decl>
	<function-decl name='atomic_and_16_nv' mangled-name='atomic_and_16_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_and_16_nv'>
	<parameter type-id='93977ae7' name='target'/>
	<parameter type-id='149c6638' name='bits'/>
	<return type-id='149c6638'/>
	</function-decl>
	- <function-decl name='atomic_and_ushort_nv' mangled-name='atomic_and_ushort_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_and_ushort_nv'>
	- <parameter type-id='8e6fdc53' name='target'/>
	- <parameter type-id='d908a348' name='bits'/>
	- <return type-id='d908a348'/>
	- </function-decl>
	<function-decl name='atomic_and_32_nv' mangled-name='atomic_and_32_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_and_32_nv'>
	<parameter type-id='3a147f31' name='target'/>
	<parameter type-id='8f92235e' name='bits'/>
	<return type-id='8f92235e'/>
	</function-decl>
	- <function-decl name='atomic_and_uint_nv' mangled-name='atomic_and_uint_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_and_uint_nv'>
	- <parameter type-id='0ea19dfa' name='target'/>
	- <parameter type-id='3502e3ff' name='bits'/>
	- <return type-id='3502e3ff'/>
	- </function-decl>
	<function-decl name='atomic_and_ulong_nv' mangled-name='atomic_and_ulong_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_and_ulong_nv'>
	<parameter type-id='64698d33' name='target'/>
	<parameter type-id='ee1f298e' name='bits'/>
	<return type-id='ee1f298e'/>
	</function-decl>
	- <function-decl name='atomic_and_64_nv' mangled-name='atomic_and_64_nv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_and_64_nv'>
	- <parameter type-id='46a83d9c' name='target'/>
	- <parameter type-id='9c313c2d' name='bits'/>
	- <return type-id='9c313c2d'/>
	- </function-decl>
	<function-decl name='atomic_cas_8' mangled-name='atomic_cas_8' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_cas_8'>
	<parameter type-id='aa323ea4' name='target'/>
	<parameter type-id='b96825af' name='exp'/>
	<parameter type-id='b96825af' name='des'/>
	<return type-id='b96825af'/>
	</function-decl>
	- <function-decl name='atomic_cas_uchar' mangled-name='atomic_cas_uchar' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_cas_uchar'>
	- <parameter type-id='b663a671' name='target'/>
	- <parameter type-id='d8bf0010' name='exp'/>
	- <parameter type-id='d8bf0010' name='des'/>
	- <return type-id='d8bf0010'/>
	- </function-decl>
	<function-decl name='atomic_cas_16' mangled-name='atomic_cas_16' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_cas_16'>
	<parameter type-id='93977ae7' name='target'/>
	<parameter type-id='149c6638' name='exp'/>
	<parameter type-id='149c6638' name='des'/>
	<return type-id='149c6638'/>
	</function-decl>
	- <function-decl name='atomic_cas_ushort' mangled-name='atomic_cas_ushort' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_cas_ushort'>
	- <parameter type-id='8e6fdc53' name='target'/>
	- <parameter type-id='d908a348' name='exp'/>
	- <parameter type-id='d908a348' name='des'/>
	- <return type-id='d908a348'/>
	- </function-decl>
	<function-decl name='atomic_cas_32' mangled-name='atomic_cas_32' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_cas_32'>
	<parameter type-id='3a147f31' name='target'/>
	<parameter type-id='8f92235e' name='exp'/>
	<parameter type-id='8f92235e' name='des'/>
	<return type-id='8f92235e'/>
	</function-decl>
	- <function-decl name='atomic_cas_uint' mangled-name='atomic_cas_uint' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_cas_uint'>
	- <parameter type-id='0ea19dfa' name='target'/>
	- <parameter type-id='3502e3ff' name='exp'/>
	- <parameter type-id='3502e3ff' name='des'/>
	- <return type-id='3502e3ff'/>
	- </function-decl>
	<function-decl name='atomic_cas_ulong' mangled-name='atomic_cas_ulong' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_cas_ulong'>
	<parameter type-id='64698d33' name='target'/>
	<parameter type-id='ee1f298e' name='exp'/>
	<parameter type-id='ee1f298e' name='des'/>
	<return type-id='ee1f298e'/>
	</function-decl>
	- <function-decl name='atomic_cas_64' mangled-name='atomic_cas_64' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_cas_64'>
	- <parameter type-id='46a83d9c' name='target'/>
	- <parameter type-id='9c313c2d' name='exp'/>
	- <parameter type-id='9c313c2d' name='des'/>
	- <return type-id='9c313c2d'/>
	- </function-decl>
	<function-decl name='atomic_cas_ptr' mangled-name='atomic_cas_ptr' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_cas_ptr'>
	<parameter type-id='fe09dd29' name='target'/>
	<parameter type-id='eaa32e2f' name='exp'/>
	<parameter type-id='eaa32e2f' name='des'/>
	<return type-id='eaa32e2f'/>
	</function-decl>
	<function-decl name='atomic_swap_8' mangled-name='atomic_swap_8' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_swap_8'>
	<parameter type-id='aa323ea4' name='target'/>
	<parameter type-id='b96825af' name='bits'/>
	<return type-id='b96825af'/>
	</function-decl>
	- <function-decl name='atomic_swap_uchar' mangled-name='atomic_swap_uchar' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_swap_uchar'>
	- <parameter type-id='b663a671' name='target'/>
	- <parameter type-id='d8bf0010' name='bits'/>
	- <return type-id='d8bf0010'/>
	- </function-decl>
	<function-decl name='atomic_swap_16' mangled-name='atomic_swap_16' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_swap_16'>
	<parameter type-id='93977ae7' name='target'/>
	<parameter type-id='149c6638' name='bits'/>
	<return type-id='149c6638'/>
	</function-decl>
	- <function-decl name='atomic_swap_ushort' mangled-name='atomic_swap_ushort' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_swap_ushort'>
	- <parameter type-id='8e6fdc53' name='target'/>
	- <parameter type-id='d908a348' name='bits'/>
	- <return type-id='d908a348'/>
	- </function-decl>
	<function-decl name='atomic_swap_32' mangled-name='atomic_swap_32' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_swap_32'>
	<parameter type-id='3a147f31' name='target'/>
	<parameter type-id='8f92235e' name='bits'/>
	<return type-id='8f92235e'/>
	</function-decl>
	- <function-decl name='atomic_swap_uint' mangled-name='atomic_swap_uint' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_swap_uint'>
	- <parameter type-id='0ea19dfa' name='target'/>
	- <parameter type-id='3502e3ff' name='bits'/>
	- <return type-id='3502e3ff'/>
	- </function-decl>
	<function-decl name='atomic_swap_ulong' mangled-name='atomic_swap_ulong' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_swap_ulong'>
	<parameter type-id='64698d33' name='target'/>
	<parameter type-id='ee1f298e' name='bits'/>
	<return type-id='ee1f298e'/>
	</function-decl>
	- <function-decl name='atomic_swap_64' mangled-name='atomic_swap_64' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_swap_64'>
	- <parameter type-id='46a83d9c' name='target'/>
	- <parameter type-id='9c313c2d' name='bits'/>
	- <return type-id='9c313c2d'/>
	- </function-decl>
	<function-decl name='atomic_swap_ptr' mangled-name='atomic_swap_ptr' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_swap_ptr'>
	<parameter type-id='fe09dd29' name='target'/>
	<parameter type-id='eaa32e2f' name='bits'/>
	<return type-id='eaa32e2f'/>
	</function-decl>
	<function-decl name='atomic_set_long_excl' mangled-name='atomic_set_long_excl' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_set_long_excl'>
	<parameter type-id='64698d33' name='target'/>
	<parameter type-id='3502e3ff' name='value'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='atomic_clear_long_excl' mangled-name='atomic_clear_long_excl' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_clear_long_excl'>
	<parameter type-id='64698d33' name='target'/>
	<parameter type-id='3502e3ff' name='value'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='membar_enter' mangled-name='membar_enter' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='membar_enter'>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='membar_exit' mangled-name='membar_exit' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='membar_exit'>
	- <return type-id='48b5725f'/>
	- </function-decl>
	<function-decl name='membar_producer' mangled-name='membar_producer' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='membar_producer'>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='membar_consumer' mangled-name='membar_consumer' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='membar_consumer'>
	<return type-id='48b5725f'/>
	</function-decl>
	- <type-decl name='short int' size-in-bits='16' id='a2185560'/>
	- <typedef-decl name='int16_t' type-id='a2185560' id='23bd8cb5'/>
	- <typedef-decl name='int32_t' type-id='95e97e5e' id='3ff5601b'/>
	- <typedef-decl name='uchar_t' type-id='002ac4a6' id='d8bf0010'/>
	- <typedef-decl name='uint64_t' type-id='7359adad' id='9c313c2d'/>
	- <pointer-type-def type-id='b0b3cbf9' size-in-bits='64' id='fe09dd29'/>
	- <qualified-type-def type-id='48b5725f' volatile='yes' id='b0b3cbf9'/>
	</abi-instr>
	- <abi-instr version='1.0' address-size='64' path='list.c' language='LANG_C89'>
	+ <abi-instr address-size='64' path='list.c' language='LANG_C99'>
	+ <typedef-decl name='list_node_t' type-id='b0b5e45e' id='b21843b2'/>
	<typedef-decl name='list_t' type-id='e824dae9' id='0899125f'/>
	+ <class-decl name='list_node' size-in-bits='128' is-struct='yes' visibility='default' id='b0b5e45e'>
	+ <data-member access='public' layout-offset-in-bits='0'>
	+ <var-decl name='next' type-id='b03eadb4' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='64'>
	+ <var-decl name='prev' type-id='b03eadb4' visibility='default'/>
	+ </data-member>
	+ </class-decl>
	<class-decl name='list' size-in-bits='256' is-struct='yes' visibility='default' id='e824dae9'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='list_size' type-id='b59d7dce' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='list_offset' type-id='b59d7dce' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='list_head' type-id='b0b5e45e' visibility='default'/>
	</data-member>
	</class-decl>
	- <class-decl name='list_node' size-in-bits='128' is-struct='yes' visibility='default' id='b0b5e45e'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='next' type-id='b03eadb4' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='prev' type-id='b03eadb4' visibility='default'/>
	- </data-member>
	- </class-decl>
	- <typedef-decl name='list_node_t' type-id='b0b5e45e' id='b21843b2'/>
	<pointer-type-def type-id='b0b5e45e' size-in-bits='64' id='b03eadb4'/>
	<pointer-type-def type-id='b21843b2' size-in-bits='64' id='ccc38265'/>
	<pointer-type-def type-id='0899125f' size-in-bits='64' id='352ec160'/>
	<function-decl name='list_create' mangled-name='list_create' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='list_create'>
	<parameter type-id='352ec160' name='list'/>
	<parameter type-id='b59d7dce' name='size'/>
	<parameter type-id='b59d7dce' name='offset'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='list_destroy' mangled-name='list_destroy' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='list_destroy'>
	<parameter type-id='352ec160' name='list'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='list_insert_head' mangled-name='list_insert_head' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='list_insert_head'>
	+ <function-decl name='list_insert_after' mangled-name='list_insert_after' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='list_insert_after'>
	<parameter type-id='352ec160' name='list'/>
	<parameter type-id='eaa32e2f' name='object'/>
	+ <parameter type-id='eaa32e2f' name='nobject'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='list_insert_after' mangled-name='list_insert_after' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='list_insert_after'>
	+ <function-decl name='list_insert_before' mangled-name='list_insert_before' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='list_insert_before'>
	<parameter type-id='352ec160' name='list'/>
	<parameter type-id='eaa32e2f' name='object'/>
	<parameter type-id='eaa32e2f' name='nobject'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='list_insert_tail' mangled-name='list_insert_tail' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='list_insert_tail'>
	+ <function-decl name='list_insert_head' mangled-name='list_insert_head' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='list_insert_head'>
	<parameter type-id='352ec160' name='list'/>
	<parameter type-id='eaa32e2f' name='object'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='list_insert_before' mangled-name='list_insert_before' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='list_insert_before'>
	+ <function-decl name='list_insert_tail' mangled-name='list_insert_tail' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='list_insert_tail'>
	<parameter type-id='352ec160' name='list'/>
	<parameter type-id='eaa32e2f' name='object'/>
	- <parameter type-id='eaa32e2f' name='nobject'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='list_remove' mangled-name='list_remove' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='list_remove'>
	<parameter type-id='352ec160' name='list'/>
	<parameter type-id='eaa32e2f' name='object'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='list_remove_head' mangled-name='list_remove_head' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='list_remove_head'>
	<parameter type-id='352ec160' name='list'/>
	<return type-id='eaa32e2f'/>
	</function-decl>
	<function-decl name='list_remove_tail' mangled-name='list_remove_tail' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='list_remove_tail'>
	<parameter type-id='352ec160' name='list'/>
	<return type-id='eaa32e2f'/>
	</function-decl>
	<function-decl name='list_head' mangled-name='list_head' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='list_head'>
	<parameter type-id='352ec160' name='list'/>
	<return type-id='eaa32e2f'/>
	</function-decl>
	<function-decl name='list_tail' mangled-name='list_tail' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='list_tail'>
	<parameter type-id='352ec160' name='list'/>
	<return type-id='eaa32e2f'/>
	</function-decl>
	<function-decl name='list_next' mangled-name='list_next' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='list_next'>
	<parameter type-id='352ec160' name='list'/>
	<parameter type-id='eaa32e2f' name='object'/>
	<return type-id='eaa32e2f'/>
	</function-decl>
	<function-decl name='list_prev' mangled-name='list_prev' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='list_prev'>
	<parameter type-id='352ec160' name='list'/>
	<parameter type-id='eaa32e2f' name='object'/>
	<return type-id='eaa32e2f'/>
	</function-decl>
	<function-decl name='list_move_tail' mangled-name='list_move_tail' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='list_move_tail'>
	<parameter type-id='352ec160' name='dst'/>
	<parameter type-id='352ec160' name='src'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='list_link_replace' mangled-name='list_link_replace' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='list_link_replace'>
	<parameter type-id='ccc38265' name='lold'/>
	<parameter type-id='ccc38265' name='lnew'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='list_link_init' mangled-name='list_link_init' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='list_link_init'>
	<parameter type-id='ccc38265' name='ln'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='list_link_active' mangled-name='list_link_active' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='list_link_active'>
	<parameter type-id='ccc38265' name='ln'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='list_is_empty' mangled-name='list_is_empty' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='list_is_empty'>
	<parameter type-id='352ec160' name='list'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	</abi-instr>
	- <abi-instr version='1.0' address-size='64' path='mkdirp.c' language='LANG_C89'>
	+ <abi-instr address-size='64' path='mkdirp.c' language='LANG_C99'>
	<typedef-decl name='mode_t' type-id='e1c52942' id='d50d396c'/>
	<typedef-decl name='wchar_t' type-id='95e97e5e' id='928221d2'/>
	<qualified-type-def type-id='928221d2' const='yes' id='effb3702'/>
	<pointer-type-def type-id='effb3702' size-in-bits='64' id='f077d3f8'/>
	+ <qualified-type-def type-id='f077d3f8' restrict='yes' id='598aab80'/>
	<pointer-type-def type-id='928221d2' size-in-bits='64' id='323d93c1'/>
	+ <qualified-type-def type-id='323d93c1' restrict='yes' id='f1358bc3'/>
	<function-decl name='mkdirp' mangled-name='mkdirp' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='mkdirp'>
	<parameter type-id='80f4b756' name='d'/>
	<parameter type-id='d50d396c' name='mode'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='mbstowcs' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='323d93c1'/>
	- <parameter type-id='80f4b756'/>
	+ <parameter type-id='f1358bc3'/>
	+ <parameter type-id='9d26089a'/>
	<parameter type-id='b59d7dce'/>
	<return type-id='b59d7dce'/>
	</function-decl>
	<function-decl name='wcstombs' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='26a90f95'/>
	- <parameter type-id='f077d3f8'/>
	+ <parameter type-id='266fe297'/>
	+ <parameter type-id='598aab80'/>
	<parameter type-id='b59d7dce'/>
	<return type-id='b59d7dce'/>
	</function-decl>
	<function-decl name='mkdir' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='80f4b756'/>
	<parameter type-id='e1c52942'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='__rawmemchr' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='eaa32e2f'/>
	- <parameter type-id='95e97e5e'/>
	- <return type-id='eaa32e2f'/>
	- </function-decl>
	- <typedef-decl name='__mode_t' type-id='f0981eeb' id='e1c52942'/>
	</abi-instr>
	- <abi-instr version='1.0' address-size='64' path='os/linux/getexecname.c' language='LANG_C89'>
	+ <abi-instr address-size='64' path='os/linux/getexecname.c' language='LANG_C99'>
	<function-decl name='getexecname' mangled-name='getexecname' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='getexecname'>
	<return type-id='80f4b756'/>
	</function-decl>
	</abi-instr>
	- <abi-instr version='1.0' address-size='64' path='os/linux/gethostid.c' language='LANG_C89'>
	+ <abi-instr address-size='64' path='os/linux/gethostid.c' language='LANG_C99'>
	<function-decl name='get_system_hostid' mangled-name='get_system_hostid' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='get_system_hostid'>
	<return type-id='7359adad'/>
	</function-decl>
	- <function-decl name='fscanf' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='822cd80b'/>
	- <parameter type-id='80f4b756'/>
	- <parameter is-variadic='yes'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='fclose' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='822cd80b'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	</abi-instr>
	- <abi-instr version='1.0' address-size='64' path='os/linux/getmntany.c' language='LANG_C89'>
	+ <abi-instr address-size='64' path='os/linux/getmntany.c' language='LANG_C99'>
	<array-type-def dimensions='1' type-id='a84c031d' size-in-bits='32880' id='ad756b7f'>
	- <subrange length='4110' type-id='4c87fef4' id='8aa676f7'/>
	+ <subrange length='4110' type-id='7359adad' id='8aa676f7'/>
	</array-type-def>
	<class-decl name='mnttab' size-in-bits='256' is-struct='yes' visibility='default' id='1b055409'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='mnt_special' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='mnt_mountp' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='mnt_fstype' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	<var-decl name='mnt_mntopts' type-id='26a90f95' visibility='default'/>
	</data-member>
	</class-decl>
	<class-decl name='extmnttab' size-in-bits='320' is-struct='yes' visibility='default' id='0c544dc0'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='mnt_special' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='mnt_mountp' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='mnt_fstype' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	<var-decl name='mnt_mntopts' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='256'>
	<var-decl name='mnt_major' type-id='3502e3ff' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='288'>
	<var-decl name='mnt_minor' type-id='3502e3ff' visibility='default'/>
	</data-member>
	</class-decl>
	<class-decl name='mntent' size-in-bits='320' is-struct='yes' visibility='default' id='56fe4a37'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='mnt_fsname' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='mnt_dir' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='mnt_type' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	<var-decl name='mnt_opts' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='256'>
	<var-decl name='mnt_freq' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='288'>
	<var-decl name='mnt_passno' type-id='95e97e5e' visibility='default'/>
	</data-member>
	</class-decl>
	<pointer-type-def type-id='0c544dc0' size-in-bits='64' id='394fc496'/>
	<pointer-type-def type-id='56fe4a37' size-in-bits='64' id='b6b61d2f'/>
	+ <qualified-type-def type-id='b6b61d2f' restrict='yes' id='3cad23cd'/>
	<pointer-type-def type-id='1b055409' size-in-bits='64' id='9d424d31'/>
	- <function-decl name='_sol_getmntent' mangled-name='_sol_getmntent' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_sol_getmntent'>
	- <parameter type-id='822cd80b' name='fp'/>
	- <parameter type-id='9d424d31' name='mgetp'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='getmntany' mangled-name='getmntany' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='getmntany'>
	- <parameter type-id='822cd80b' name='fp'/>
	- <parameter type-id='9d424d31' name='mgetp'/>
	- <parameter type-id='9d424d31' name='mrefp'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='getextmntent' mangled-name='getextmntent' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='getextmntent'>
	- <parameter type-id='80f4b756' name='path'/>
	- <parameter type-id='394fc496' name='entry'/>
	- <parameter type-id='62f7a03d' name='statbuf'/>
	- <return type-id='95e97e5e'/>
	+ <function-decl name='getmntent_r' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='e75a27e9'/>
	+ <parameter type-id='3cad23cd'/>
	+ <parameter type-id='266fe297'/>
	+ <parameter type-id='95e97e5e'/>
	+ <return type-id='b6b61d2f'/>
	</function-decl>
	- <var-decl name='buf' type-id='ad756b7f' mangled-name='buf' visibility='default' elf-symbol-id='buf'/>
	<function-decl name='feof' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='822cd80b'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='getmntent_r' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='822cd80b'/>
	- <parameter type-id='b6b61d2f'/>
	- <parameter type-id='26a90f95'/>
	- <parameter type-id='95e97e5e'/>
	- <return type-id='b6b61d2f'/>
	- </function-decl>
	- <pointer-type-def type-id='0bbec9cd' size-in-bits='64' id='62f7a03d'/>
	- <class-decl name='stat64' size-in-bits='1152' is-struct='yes' visibility='default' id='0bbec9cd'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='st_dev' type-id='35ed8932' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='st_ino' type-id='71288a47' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='st_nlink' type-id='80f0b9df' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='192'>
	- <var-decl name='st_mode' type-id='e1c52942' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='224'>
	- <var-decl name='st_uid' type-id='cc5fcceb' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='256'>
	- <var-decl name='st_gid' type-id='d94ec6d9' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='288'>
	- <var-decl name='__pad0' type-id='95e97e5e' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='320'>
	- <var-decl name='st_rdev' type-id='35ed8932' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='384'>
	- <var-decl name='st_size' type-id='79989e9c' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='448'>
	- <var-decl name='st_blksize' type-id='d3f10a7f' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='512'>
	- <var-decl name='st_blocks' type-id='4e711bf1' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='576'>
	- <var-decl name='st_atim' type-id='a9c79a1f' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='704'>
	- <var-decl name='st_mtim' type-id='a9c79a1f' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='832'>
	- <var-decl name='st_ctim' type-id='a9c79a1f' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='960'>
	- <var-decl name='__unused' type-id='083f8d58' visibility='default'/>
	- </data-member>
	- </class-decl>
	- <array-type-def dimensions='1' type-id='03085adc' size-in-bits='192' id='083f8d58'>
	- <subrange length='3' type-id='4c87fef4' id='56f209d2'/>
	- </array-type-def>
	- <class-decl name='timespec' size-in-bits='128' is-struct='yes' visibility='default' id='a9c79a1f'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='tv_sec' type-id='65eda9c0' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='tv_nsec' type-id='03085adc' visibility='default'/>
	- </data-member>
	- </class-decl>
	- <typedef-decl name='__blkcnt64_t' type-id='bd54fe1a' id='4e711bf1'/>
	- <typedef-decl name='__blksize_t' type-id='bd54fe1a' id='d3f10a7f'/>
	- <typedef-decl name='__dev_t' type-id='7359adad' id='35ed8932'/>
	- <typedef-decl name='__gid_t' type-id='f0981eeb' id='d94ec6d9'/>
	- <typedef-decl name='__ino64_t' type-id='7359adad' id='71288a47'/>
	- <typedef-decl name='__nlink_t' type-id='7359adad' id='80f0b9df'/>
	- <typedef-decl name='__uid_t' type-id='f0981eeb' id='cc5fcceb'/>
	- <typedef-decl name='__syscall_slong_t' type-id='bd54fe1a' id='03085adc'/>
	- <typedef-decl name='__time_t' type-id='bd54fe1a' id='65eda9c0'/>
	+ <var-decl name='buf' type-id='ad756b7f' mangled-name='buf' visibility='default' elf-symbol-id='buf'/>
	+ <function-decl name='getmntany' mangled-name='getmntany' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='getmntany'>
	+ <parameter type-id='822cd80b' name='fp'/>
	+ <parameter type-id='9d424d31' name='mgetp'/>
	+ <parameter type-id='9d424d31' name='mrefp'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='_sol_getmntent' mangled-name='_sol_getmntent' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_sol_getmntent'>
	+ <parameter type-id='822cd80b' name='fp'/>
	+ <parameter type-id='9d424d31' name='mgetp'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='getextmntent' mangled-name='getextmntent' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='getextmntent'>
	+ <parameter type-id='80f4b756' name='path'/>
	+ <parameter type-id='394fc496' name='entry'/>
	+ <parameter type-id='62f7a03d' name='statbuf'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	</abi-instr>
	- <abi-instr version='1.0' address-size='64' path='os/linux/zone.c' language='LANG_C89'>
	+ <abi-instr address-size='64' path='os/linux/zone.c' language='LANG_C99'>
	<typedef-decl name='zoneid_t' type-id='95e97e5e' id='4da03624'/>
	<function-decl name='getzoneid' mangled-name='getzoneid' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='getzoneid'>
	<return type-id='4da03624'/>
	</function-decl>
	</abi-instr>
	- <abi-instr version='1.0' address-size='64' path='page.c' language='LANG_C89'>
	+ <abi-instr address-size='64' path='page.c' language='LANG_C99'>
	<var-decl name='pagesize' type-id='b59d7dce' mangled-name='pagesize' visibility='default' elf-symbol-id='pagesize'/>
	</abi-instr>
	- <abi-instr version='1.0' address-size='64' path='timestamp.c' language='LANG_C89'>
	+ <abi-instr address-size='64' path='strlcat.c' language='LANG_C99'>
	+ <function-decl name='memcpy' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='eaa32e2f'/>
	+ <parameter type-id='eaa32e2f'/>
	+ <parameter type-id='b59d7dce'/>
	+ <return type-id='eaa32e2f'/>
	+ </function-decl>
	+ </abi-instr>
	+ <abi-instr address-size='64' path='timestamp.c' language='LANG_C99'>
	<class-decl name='tm' size-in-bits='448' is-struct='yes' visibility='default' id='dddf6ca2'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='tm_sec' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='32'>
	<var-decl name='tm_min' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='tm_hour' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='96'>
	<var-decl name='tm_mday' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='tm_mon' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='160'>
	<var-decl name='tm_year' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	<var-decl name='tm_wday' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='224'>
	<var-decl name='tm_yday' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='256'>
	<var-decl name='tm_isdst' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='320'>
	<var-decl name='tm_gmtoff' type-id='bd54fe1a' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='384'>
	<var-decl name='tm_zone' type-id='80f4b756' visibility='default'/>
	</data-member>
	</class-decl>
	<typedef-decl name='time_t' type-id='65eda9c0' id='c9d12d66'/>
	<typedef-decl name='nl_item' type-id='95e97e5e' id='03b79a94'/>
	<qualified-type-def type-id='c9d12d66' const='yes' id='588b3216'/>
	<pointer-type-def type-id='588b3216' size-in-bits='64' id='9f201474'/>
	<qualified-type-def type-id='dddf6ca2' const='yes' id='e824a34f'/>
	<pointer-type-def type-id='e824a34f' size-in-bits='64' id='d6ad37ff'/>
	+ <qualified-type-def type-id='d6ad37ff' restrict='yes' id='f8c6051d'/>
	<pointer-type-def type-id='c9d12d66' size-in-bits='64' id='b2eb2c3f'/>
	<pointer-type-def type-id='dddf6ca2' size-in-bits='64' id='d915a820'/>
	<function-decl name='print_timestamp' mangled-name='print_timestamp' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='print_timestamp'>
	<parameter type-id='3502e3ff' name='timestamp_fmt'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='localtime' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='9f201474'/>
	- <return type-id='d915a820'/>
	- </function-decl>
	- <function-decl name='strftime' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='26a90f95'/>
	- <parameter type-id='b59d7dce'/>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='d6ad37ff'/>
	- <return type-id='b59d7dce'/>
	+ <function-decl name='nl_langinfo' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='03b79a94'/>
	+ <return type-id='26a90f95'/>
	</function-decl>
	<function-decl name='time' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='b2eb2c3f'/>
	<return type-id='c9d12d66'/>
	</function-decl>
	- <function-decl name='nl_langinfo' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='03b79a94'/>
	- <return type-id='26a90f95'/>
	+ <function-decl name='strftime' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='266fe297'/>
	+ <parameter type-id='b59d7dce'/>
	+ <parameter type-id='9d26089a'/>
	+ <parameter type-id='f8c6051d'/>
	+ <return type-id='b59d7dce'/>
	+ </function-decl>
	+ <function-decl name='localtime' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='9f201474'/>
	+ <return type-id='d915a820'/>
	</function-decl>
	</abi-instr>
	- <abi-instr version='1.0' address-size='64' path='thread_pool.c' language='LANG_C89'>
	- <array-type-def dimensions='1' type-id='37961329' size-in-bits='576' id='fbc192a1'>
	- <subrange length='1' type-id='4c87fef4' id='52f813b4'/>
	+ <abi-instr address-size='64' path='thread_pool.c' language='LANG_C99'>
	+ <array-type-def dimensions='1' type-id='8901473c' size-in-bits='576' id='f5da478b'>
	+ <subrange length='1' type-id='7359adad' id='52f813b4'/>
	</array-type-def>
	<array-type-def dimensions='1' type-id='49ef3ffd' size-in-bits='1024' id='a14403f5'>
	- <subrange length='16' type-id='4c87fef4' id='848d0938'/>
	+ <subrange length='16' type-id='7359adad' id='848d0938'/>
	</array-type-def>
	<array-type-def dimensions='1' type-id='a84c031d' size-in-bits='384' id='36d7f119'>
	- <subrange length='48' type-id='4c87fef4' id='8f6d2a81'/>
	+ <subrange length='48' type-id='7359adad' id='8f6d2a81'/>
	</array-type-def>
	- <class-decl name='__jmp_buf_tag' is-struct='yes' visibility='default' is-declaration-only='yes' id='95989dcf'/>
	<array-type-def dimensions='1' type-id='bd54fe1a' size-in-bits='512' id='5d4efd44'>
	- <subrange length='8' type-id='4c87fef4' id='56e0c0b1'/>
	+ <subrange length='8' type-id='7359adad' id='56e0c0b1'/>
	+ </array-type-def>
	+ <array-type-def dimensions='1' type-id='f0981eeb' size-in-bits='64' id='0d532ec1'>
	+ <subrange length='2' type-id='7359adad' id='52efc4ef'/>
	</array-type-def>
	<array-type-def dimensions='1' type-id='7359adad' size-in-bits='1024' id='d2baa450'>
	- <subrange length='16' type-id='4c87fef4' id='848d0938'/>
	+ <subrange length='16' type-id='7359adad' id='848d0938'/>
	</array-type-def>
	<array-type-def dimensions='1' type-id='eaa32e2f' size-in-bits='256' id='209ef23f'>
	- <subrange length='4' type-id='4c87fef4' id='16fe7105'/>
	+ <subrange length='4' type-id='7359adad' id='16fe7105'/>
	</array-type-def>
	- <typedef-decl name='pthread_cond_t' type-id='2f802b4a' id='62fab762'/>
	- <union-decl name='__anonymous_union__' size-in-bits='384' is-anonymous='yes' visibility='default' id='2f802b4a'>
	- <data-member access='private'>
	- <var-decl name='__data' type-id='7a80c843' visibility='default'/>
	+ <typedef-decl name='tpool_job_t' type-id='3b8579e5' id='66a0afc9'/>
	+ <class-decl name='tpool_job' size-in-bits='192' is-struct='yes' visibility='default' id='3b8579e5'>
	+ <data-member access='public' layout-offset-in-bits='0'>
	+ <var-decl name='tpj_next' type-id='f32b30e4' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='64'>
	+ <var-decl name='tpj_func' type-id='b7f9d8e6' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='128'>
	+ <var-decl name='tpj_arg' type-id='eaa32e2f' visibility='default'/>
	+ </data-member>
	+ </class-decl>
	+ <typedef-decl name='tpool_active_t' type-id='c8d086f4' id='6fcda10e'/>
	+ <class-decl name='tpool_active' size-in-bits='128' is-struct='yes' visibility='default' id='c8d086f4'>
	+ <data-member access='public' layout-offset-in-bits='0'>
	+ <var-decl name='tpa_next' type-id='ad33e5e7' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='64'>
	+ <var-decl name='tpa_tid' type-id='4051f5e7' visibility='default'/>
	+ </data-member>
	+ </class-decl>
	+ <typedef-decl name='__cpu_mask' type-id='7359adad' id='49ef3ffd'/>
	+ <class-decl name='cpu_set_t' size-in-bits='1024' is-struct='yes' naming-typedef-id='8037c762' visibility='default' id='1f20d231'>
	+ <data-member access='public' layout-offset-in-bits='0'>
	+ <var-decl name='__bits' type-id='a14403f5' visibility='default'/>
	+ </data-member>
	+ </class-decl>
	+ <typedef-decl name='cpu_set_t' type-id='1f20d231' id='8037c762'/>
	+ <typedef-decl name='pthread_t' type-id='7359adad' id='4051f5e7'/>
	+ <union-decl name='pthread_condattr_t' size-in-bits='32' naming-typedef-id='836265dd' visibility='default' id='33dd3aad'>
	+ <data-member access='public'>
	+ <var-decl name='__size' type-id='8e0573fd' visibility='default'/>
	+ </data-member>
	+ <data-member access='public'>
	+ <var-decl name='__align' type-id='95e97e5e' visibility='default'/>
	+ </data-member>
	+ </union-decl>
	+ <typedef-decl name='pthread_condattr_t' type-id='33dd3aad' id='836265dd'/>
	+ <union-decl name='pthread_cond_t' size-in-bits='384' naming-typedef-id='62fab762' visibility='default' id='cbb12c12'>
	+ <data-member access='public'>
	+ <var-decl name='__data' type-id='c987b47c' visibility='default'/>
	</data-member>
	- <data-member access='private'>
	+ <data-member access='public'>
	<var-decl name='__size' type-id='36d7f119' visibility='default'/>
	</data-member>
	- <data-member access='private'>
	+ <data-member access='public'>
	<var-decl name='__align' type-id='1eb56b1e' visibility='default'/>
	</data-member>
	</union-decl>
	- <class-decl name='__anonymous_struct__' size-in-bits='384' is-struct='yes' is-anonymous='yes' visibility='default' id='7a80c843'>
	+ <typedef-decl name='pthread_cond_t' type-id='cbb12c12' id='62fab762'/>
	+ <typedef-decl name='__jmp_buf' type-id='5d4efd44' id='379a1ab7'/>
	+ <class-decl name='__pthread_cond_s' size-in-bits='384' is-struct='yes' visibility='default' id='c987b47c'>
	<data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='__lock' type-id='95e97e5e' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='32'>
	- <var-decl name='__futex' type-id='f0981eeb' visibility='default'/>
	+ <var-decl name='' type-id='ac5ab595' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='__total_seq' type-id='3a47d82b' visibility='default'/>
	+ <var-decl name='' type-id='ac5ab596' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='__wakeup_seq' type-id='3a47d82b' visibility='default'/>
	+ <var-decl name='__g_refs' type-id='0d532ec1' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	- <var-decl name='__woken_seq' type-id='3a47d82b' visibility='default'/>
	+ <var-decl name='__g_size' type-id='0d532ec1' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='256'>
	- <var-decl name='__mutex' type-id='eaa32e2f' visibility='default'/>
	+ <var-decl name='__g1_orig_size' type-id='f0981eeb' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='320'>
	- <var-decl name='__nwaiters' type-id='f0981eeb' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='288'>
	+ <var-decl name='__wrefs' type-id='f0981eeb' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='352'>
	- <var-decl name='__broadcast_seq' type-id='f0981eeb' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='320'>
	+ <var-decl name='__g_signals' type-id='0d532ec1' visibility='default'/>
	</data-member>
	</class-decl>
	- <class-decl name='tpool_active' size-in-bits='128' is-struct='yes' visibility='default' id='c8d086f4'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='tpa_next' type-id='ad33e5e7' visibility='default'/>
	+ <union-decl name='__anonymous_union__1' size-in-bits='64' is-anonymous='yes' visibility='default' id='ac5ab595'>
	+ <data-member access='public'>
	+ <var-decl name='__wseq' type-id='3a47d82b' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='tpa_tid' type-id='4051f5e7' visibility='default'/>
	+ <data-member access='public'>
	+ <var-decl name='__wseq32' type-id='e7f43f72' visibility='default'/>
	</data-member>
	- </class-decl>
	- <typedef-decl name='tpool_active_t' type-id='c8d086f4' id='6fcda10e'/>
	- <typedef-decl name='pthread_t' type-id='7359adad' id='4051f5e7'/>
	- <class-decl name='tpool_job' size-in-bits='192' is-struct='yes' visibility='default' id='3b8579e5'>
	+ </union-decl>
	+ <class-decl name='__anonymous_struct__' size-in-bits='64' is-struct='yes' is-anonymous='yes' visibility='default' id='e7f43f72'>
	<data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='tpj_next' type-id='f32b30e4' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='tpj_func' type-id='b7f9d8e6' visibility='default'/>
	+ <var-decl name='__low' type-id='f0981eeb' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='tpj_arg' type-id='eaa32e2f' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='32'>
	+ <var-decl name='__high' type-id='f0981eeb' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='tpool_job_t' type-id='3b8579e5' id='66a0afc9'/>
	- <typedef-decl name='__sigset_t' type-id='b7c5dddc' id='b9c97942'/>
	- <class-decl name='__anonymous_struct__1' size-in-bits='1024' is-struct='yes' is-anonymous='yes' naming-typedef-id='b9c97942' visibility='default' id='b7c5dddc'>
	+ <union-decl name='__anonymous_union__2' size-in-bits='64' is-anonymous='yes' visibility='default' id='ac5ab596'>
	+ <data-member access='public'>
	+ <var-decl name='__g1_start' type-id='3a47d82b' visibility='default'/>
	+ </data-member>
	+ <data-member access='public'>
	+ <var-decl name='__g1_start32' type-id='e7f43f72' visibility='default'/>
	+ </data-member>
	+ </union-decl>
	+ <class-decl name='__sigset_t' size-in-bits='1024' is-struct='yes' naming-typedef-id='b9c97942' visibility='default' id='2616147f'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='__val' type-id='d2baa450' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='__pthread_unwind_buf_t' type-id='73de4187' id='4423cf7f'/>
	- <class-decl name='__anonymous_struct__2' size-in-bits='832' is-struct='yes' is-anonymous='yes' naming-typedef-id='4423cf7f' visibility='default' id='73de4187'>
	+ <typedef-decl name='__sigset_t' type-id='2616147f' id='b9c97942'/>
	+ <class-decl name='sched_param' size-in-bits='32' is-struct='yes' visibility='default' id='0897719a'>
	<data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='__cancel_jmp_buf' type-id='fbc192a1' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='576'>
	- <var-decl name='__pad' type-id='209ef23f' visibility='default'/>
	+ <var-decl name='sched_priority' type-id='95e97e5e' visibility='default'/>
	</data-member>
	</class-decl>
	- <class-decl name='__anonymous_struct__3' size-in-bits='576' is-struct='yes' is-anonymous='yes' visibility='default' id='37961329'>
	+ <class-decl name='__cancel_jmp_buf_tag' size-in-bits='576' is-struct='yes' visibility='default' id='8901473c'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='__cancel_jmp_buf' type-id='379a1ab7' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='512'>
	<var-decl name='__mask_was_saved' type-id='95e97e5e' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='__jmp_buf' type-id='5d4efd44' id='379a1ab7'/>
	- <typedef-decl name='cpu_set_t' type-id='15293686' id='8037c762'/>
	- <class-decl name='__anonymous_struct__4' size-in-bits='1024' is-struct='yes' is-anonymous='yes' naming-typedef-id='8037c762' visibility='default' id='15293686'>
	+ <class-decl name='__pthread_unwind_buf_t' size-in-bits='832' is-struct='yes' naming-typedef-id='4423cf7f' visibility='default' id='a0abc656'>
	<data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='__bits' type-id='a14403f5' visibility='default'/>
	+ <var-decl name='__cancel_jmp_buf' type-id='f5da478b' visibility='default'/>
	</data-member>
	- </class-decl>
	- <typedef-decl name='__cpu_mask' type-id='7359adad' id='49ef3ffd'/>
	- <class-decl name='sched_param' size-in-bits='32' is-struct='yes' visibility='default' id='0897719a'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='__sched_priority' type-id='95e97e5e' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='576'>
	+ <var-decl name='__pad' type-id='209ef23f' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='pthread_condattr_t' type-id='e7fcd879' id='836265dd'/>
	- <pointer-type-def type-id='95989dcf' size-in-bits='64' id='e4581527'/>
	+ <typedef-decl name='__pthread_unwind_buf_t' type-id='a0abc656' id='4423cf7f'/>
	+ <pointer-type-def type-id='8901473c' size-in-bits='64' id='eb91b7ea'/>
	<pointer-type-def type-id='4423cf7f' size-in-bits='64' id='ba7c727c'/>
	<pointer-type-def type-id='b9c97942' size-in-bits='64' id='bbf06c47'/>
	+ <qualified-type-def type-id='bbf06c47' restrict='yes' id='65e6ec45'/>
	<qualified-type-def type-id='b9c97942' const='yes' id='191f6b72'/>
	<pointer-type-def type-id='191f6b72' size-in-bits='64' id='e475fb88'/>
	+ <qualified-type-def type-id='e475fb88' restrict='yes' id='5a8729d0'/>
	<qualified-type-def type-id='8037c762' const='yes' id='f50ea9b2'/>
	<pointer-type-def type-id='f50ea9b2' size-in-bits='64' id='5e14fa48'/>
	<qualified-type-def type-id='7d8569fd' const='yes' id='e06dee2d'/>
	<pointer-type-def type-id='e06dee2d' size-in-bits='64' id='540db505'/>
	+ <qualified-type-def type-id='540db505' restrict='yes' id='e1815e87'/>
	<qualified-type-def type-id='836265dd' const='yes' id='7d24c58d'/>
	<pointer-type-def type-id='7d24c58d' size-in-bits='64' id='a7e325e5'/>
	+ <qualified-type-def type-id='a7e325e5' restrict='yes' id='4c428e67'/>
	<qualified-type-def type-id='0897719a' const='yes' id='c4a7b189'/>
	<pointer-type-def type-id='c4a7b189' size-in-bits='64' id='36fca399'/>
	+ <qualified-type-def type-id='36fca399' restrict='yes' id='37e4897b'/>
	<qualified-type-def type-id='a9c79a1f' const='yes' id='cd087e36'/>
	<pointer-type-def type-id='cd087e36' size-in-bits='64' id='e05e8614'/>
	+ <qualified-type-def type-id='e05e8614' restrict='yes' id='0be2e71c'/>
	<pointer-type-def type-id='8037c762' size-in-bits='64' id='d74a6869'/>
	+ <qualified-type-def type-id='7292109c' restrict='yes' id='6942f6a4'/>
	+ <qualified-type-def type-id='7347a39e' restrict='yes' id='578ba182'/>
	<pointer-type-def type-id='62fab762' size-in-bits='64' id='db285b03'/>
	+ <qualified-type-def type-id='db285b03' restrict='yes' id='2a468b41'/>
	+ <qualified-type-def type-id='18c91f9e' restrict='yes' id='6e745582'/>
	<pointer-type-def type-id='4051f5e7' size-in-bits='64' id='e01b5462'/>
	+ <qualified-type-def type-id='e01b5462' restrict='yes' id='cc338b26'/>
	<pointer-type-def type-id='0897719a' size-in-bits='64' id='23cbcb08'/>
	+ <qualified-type-def type-id='23cbcb08' restrict='yes' id='b09b2050'/>
	+ <qualified-type-def type-id='78c01427' restrict='yes' id='d19b2c25'/>
	<pointer-type-def type-id='6fcda10e' size-in-bits='64' id='ad33e5e7'/>
	<pointer-type-def type-id='66a0afc9' size-in-bits='64' id='f32b30e4'/>
	<pointer-type-def type-id='cd5d79f4' size-in-bits='64' id='5ad9edb6'/>
	+ <qualified-type-def type-id='eaa32e2f' restrict='yes' id='1b7446cd'/>
	+ <qualified-type-def type-id='63e171df' restrict='yes' id='9e7a3a7d'/>
	<function-decl name='tpool_abandon' mangled-name='tpool_abandon' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='tpool_abandon'>
	<parameter type-id='9cf59a50' name='tpool'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='tpool_suspend' mangled-name='tpool_suspend' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='tpool_suspend'>
	<parameter type-id='9cf59a50' name='tpool'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='tpool_suspended' mangled-name='tpool_suspended' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='tpool_suspended'>
	<parameter type-id='9cf59a50' name='tpool'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='tpool_resume' mangled-name='tpool_resume' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='tpool_resume'>
	<parameter type-id='9cf59a50' name='tpool'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='tpool_member' mangled-name='tpool_member' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='tpool_member'>
	<parameter type-id='9cf59a50' name='tpool'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='pthread_attr_destroy' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='7347a39e'/>
	- <return type-id='95e97e5e'/>
	+ <function-decl name='__sysconf' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='95e97e5e'/>
	+ <return type-id='bd54fe1a'/>
	</function-decl>
	<function-decl name='pthread_sigmask' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='95e97e5e'/>
	- <parameter type-id='e475fb88'/>
	- <parameter type-id='bbf06c47'/>
	+ <parameter type-id='5a8729d0'/>
	+ <parameter type-id='65e6ec45'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='pthread_create' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='e01b5462'/>
	- <parameter type-id='540db505'/>
	+ <parameter type-id='cc338b26'/>
	+ <parameter type-id='e1815e87'/>
	<parameter type-id='5ad9edb6'/>
	- <parameter type-id='eaa32e2f'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='pthread_cond_broadcast' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='db285b03'/>
	+ <parameter type-id='1b7446cd'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='pthread_self' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='4051f5e7'/>
	</function-decl>
	- <function-decl name='pthread_cond_timedwait' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='db285b03'/>
	- <parameter type-id='18c91f9e'/>
	- <parameter type-id='e05e8614'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='pthread_setcanceltype' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='95e97e5e'/>
	- <parameter type-id='7292109c'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='pthread_setcancelstate' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='95e97e5e'/>
	- <parameter type-id='7292109c'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='__sigsetjmp' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='e4581527'/>
	- <parameter type-id='95e97e5e'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='__pthread_register_cancel' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='ba7c727c'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	- <function-decl name='__pthread_unregister_cancel' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='ba7c727c'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	- <function-decl name='__pthread_unwind_next' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='ba7c727c'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	- <function-decl name='pthread_cond_wait' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='db285b03'/>
	- <parameter type-id='18c91f9e'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	<function-decl name='pthread_attr_init' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='7347a39e'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='pthread_attr_getaffinity_np' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='540db505'/>
	- <parameter type-id='b59d7dce'/>
	- <parameter type-id='d74a6869'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='pthread_attr_setaffinity_np' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='pthread_attr_destroy' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='7347a39e'/>
	- <parameter type-id='b59d7dce'/>
	- <parameter type-id='5e14fa48'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='pthread_attr_getdetachstate' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='540db505'/>
	<parameter type-id='7292109c'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='pthread_attr_setdetachstate' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='7347a39e'/>
	<parameter type-id='95e97e5e'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='pthread_attr_getguardsize' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='540db505'/>
	<parameter type-id='78c01427'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='pthread_attr_setguardsize' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='7347a39e'/>
	<parameter type-id='b59d7dce'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='pthread_attr_getinheritsched' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='540db505'/>
	- <parameter type-id='7292109c'/>
	+ <function-decl name='pthread_attr_getschedparam' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='e1815e87'/>
	+ <parameter type-id='b09b2050'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='pthread_attr_setinheritsched' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='7347a39e'/>
	- <parameter type-id='95e97e5e'/>
	+ <function-decl name='pthread_attr_setschedparam' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='578ba182'/>
	+ <parameter type-id='37e4897b'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='pthread_attr_getschedparam' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='540db505'/>
	- <parameter type-id='23cbcb08'/>
	+ <function-decl name='pthread_attr_getschedpolicy' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='e1815e87'/>
	+ <parameter type-id='6942f6a4'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='pthread_attr_setschedparam' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='pthread_attr_setschedpolicy' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='7347a39e'/>
	- <parameter type-id='36fca399'/>
	+ <parameter type-id='95e97e5e'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='pthread_attr_getschedpolicy' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='540db505'/>
	- <parameter type-id='7292109c'/>
	+ <function-decl name='pthread_attr_getinheritsched' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='e1815e87'/>
	+ <parameter type-id='6942f6a4'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='pthread_attr_setschedpolicy' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='pthread_attr_setinheritsched' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='7347a39e'/>
	<parameter type-id='95e97e5e'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='pthread_attr_getscope' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='540db505'/>
	- <parameter type-id='7292109c'/>
	+ <parameter type-id='e1815e87'/>
	+ <parameter type-id='6942f6a4'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='pthread_attr_setscope' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='7347a39e'/>
	<parameter type-id='95e97e5e'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='pthread_attr_getstack' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='540db505'/>
	- <parameter type-id='63e171df'/>
	- <parameter type-id='78c01427'/>
	+ <parameter type-id='e1815e87'/>
	+ <parameter type-id='9e7a3a7d'/>
	+ <parameter type-id='d19b2c25'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='pthread_attr_setstack' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='7347a39e'/>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='b59d7dce'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	+ <function-decl name='pthread_attr_setaffinity_np' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='7347a39e'/>
	+ <parameter type-id='b59d7dce'/>
	+ <parameter type-id='5e14fa48'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='pthread_attr_getaffinity_np' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='540db505'/>
	+ <parameter type-id='b59d7dce'/>
	+ <parameter type-id='d74a6869'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='pthread_setcancelstate' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='95e97e5e'/>
	+ <parameter type-id='7292109c'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='pthread_setcanceltype' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='95e97e5e'/>
	+ <parameter type-id='7292109c'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='pthread_cancel' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='4051f5e7'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='__pthread_register_cancel' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='ba7c727c'/>
	+ <return type-id='48b5725f'/>
	+ </function-decl>
	+ <function-decl name='__pthread_unregister_cancel' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='ba7c727c'/>
	+ <return type-id='48b5725f'/>
	+ </function-decl>
	+ <function-decl name='__pthread_unwind_next' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='ba7c727c'/>
	+ <return type-id='48b5725f'/>
	+ </function-decl>
	<function-decl name='pthread_cond_init' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='db285b03'/>
	- <parameter type-id='a7e325e5'/>
	+ <parameter type-id='2a468b41'/>
	+ <parameter type-id='4c428e67'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='pthread_cond_signal' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='db285b03'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='pthread_cancel' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='4051f5e7'/>
	+ <function-decl name='pthread_cond_broadcast' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='db285b03'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='pthread_cond_wait' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='2a468b41'/>
	+ <parameter type-id='6e745582'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='pthread_cond_timedwait' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='2a468b41'/>
	+ <parameter type-id='6e745582'/>
	+ <parameter type-id='0be2e71c'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-type size-in-bits='64' id='cd5d79f4'>
	<parameter type-id='eaa32e2f'/>
	<return type-id='eaa32e2f'/>
	- </function-type>
	- <pointer-type-def type-id='95e97e5e' size-in-bits='64' id='7292109c'/>
	- <type-decl name='long long unsigned int' size-in-bits='64' id='3a47d82b'/>
	- <pointer-type-def type-id='7d8569fd' size-in-bits='64' id='7347a39e'/>
	- <pointer-type-def type-id='7a6844eb' size-in-bits='64' id='18c91f9e'/>
	- <pointer-type-def type-id='b59d7dce' size-in-bits='64' id='78c01427'/>
	+ </function-type>
	<pointer-type-def type-id='b1bbf10d' size-in-bits='64' id='9cf59a50'/>
	- <typedef-decl name='pthread_attr_t' type-id='b63afacd' id='7d8569fd'/>
	- <union-decl name='__anonymous_union__1' size-in-bits='32' is-anonymous='yes' visibility='default' id='e7fcd879'>
	- <data-member access='private'>
	- <var-decl name='__size' type-id='8e0573fd' visibility='default'/>
	- </data-member>
	- <data-member access='private'>
	- <var-decl name='__align' type-id='95e97e5e' visibility='default'/>
	- </data-member>
	- </union-decl>
	- <pointer-type-def type-id='c5c76c9c' size-in-bits='64' id='b7f9d8e6'/>
	- <pointer-type-def type-id='eaa32e2f' size-in-bits='64' id='63e171df'/>
	- <array-type-def dimensions='1' type-id='a84c031d' size-in-bits='32' id='8e0573fd'>
	- <subrange length='4' type-id='4c87fef4' id='16fe7105'/>
	- </array-type-def>
	- <typedef-decl name='pthread_mutex_t' type-id='c4794498' id='7a6844eb'/>
	<typedef-decl name='tpool_t' type-id='88d1b7f9' id='b1bbf10d'/>
	- <union-decl name='pthread_attr_t' size-in-bits='448' visibility='default' id='b63afacd'>
	- <data-member access='private'>
	- <var-decl name='__size' type-id='6093ff7c' visibility='default'/>
	- </data-member>
	- <data-member access='private'>
	- <var-decl name='__align' type-id='bd54fe1a' visibility='default'/>
	- </data-member>
	- </union-decl>
	- <array-type-def dimensions='1' type-id='a84c031d' size-in-bits='448' id='6093ff7c'>
	- <subrange length='56' type-id='4c87fef4' id='f8137894'/>
	- </array-type-def>
	<class-decl name='tpool' size-in-bits='2496' is-struct='yes' visibility='default' id='88d1b7f9'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='tp_forw' type-id='9cf59a50' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='tp_back' type-id='9cf59a50' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='tp_mutex' type-id='7a6844eb' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='448'>
	<var-decl name='tp_busycv' type-id='62fab762' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='832'>
	<var-decl name='tp_workcv' type-id='62fab762' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='1216'>
	<var-decl name='tp_waitcv' type-id='62fab762' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='1600'>
	<var-decl name='tp_active' type-id='ad33e5e7' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='1664'>
	<var-decl name='tp_head' type-id='f32b30e4' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='1728'>
	<var-decl name='tp_tail' type-id='f32b30e4' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='1792'>
	<var-decl name='tp_attr' type-id='7d8569fd' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='2240'>
	<var-decl name='tp_flags' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='2272'>
	<var-decl name='tp_linger' type-id='3502e3ff' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='2304'>
	<var-decl name='tp_njobs' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='2336'>
	<var-decl name='tp_minimum' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='2368'>
	<var-decl name='tp_maximum' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='2400'>
	<var-decl name='tp_current' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='2432'>
	<var-decl name='tp_idle' type-id='95e97e5e' visibility='default'/>
	</data-member>
	</class-decl>
	- <union-decl name='__anonymous_union__1' size-in-bits='320' is-anonymous='yes' visibility='default' id='c4794498'>
	- <data-member access='private'>
	- <var-decl name='__data' type-id='4c734837' visibility='default'/>
	- </data-member>
	- <data-member access='private'>
	- <var-decl name='__size' type-id='36c46961' visibility='default'/>
	- </data-member>
	- <data-member access='private'>
	- <var-decl name='__align' type-id='bd54fe1a' visibility='default'/>
	- </data-member>
	- </union-decl>
	- <array-type-def dimensions='1' type-id='a84c031d' size-in-bits='320' id='36c46961'>
	- <subrange length='40' type-id='4c87fef4' id='8f80b239'/>
	- </array-type-def>
	- <class-decl name='__pthread_mutex_s' size-in-bits='320' is-struct='yes' visibility='default' id='4c734837'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='__lock' type-id='95e97e5e' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='32'>
	- <var-decl name='__count' type-id='f0981eeb' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='__owner' type-id='95e97e5e' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='96'>
	- <var-decl name='__nusers' type-id='f0981eeb' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='__kind' type-id='95e97e5e' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='160'>
	- <var-decl name='__spins' type-id='a2185560' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='176'>
	- <var-decl name='__elision' type-id='a2185560' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='192'>
	- <var-decl name='__list' type-id='518fb49c' visibility='default'/>
	- </data-member>
	- </class-decl>
	- <typedef-decl name='__pthread_list_t' type-id='0e01899c' id='518fb49c'/>
	- <class-decl name='__pthread_internal_list' size-in-bits='128' is-struct='yes' visibility='default' id='0e01899c'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='__prev' type-id='4d98cd5a' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='__next' type-id='4d98cd5a' visibility='default'/>
	- </data-member>
	- </class-decl>
	- <pointer-type-def type-id='0e01899c' size-in-bits='64' id='4d98cd5a'/>
	+ <function-type size-in-bits='64' id='c5c76c9c'>
	+ <parameter type-id='eaa32e2f'/>
	+ <return type-id='48b5725f'/>
	+ </function-type>
	</abi-instr>
	- <abi-instr version='1.0' address-size='64' path='libzfs_core.c' language='LANG_C89'>
	+ <abi-instr address-size='64' path='libzfs_core.c' language='LANG_C99'>
	<type-decl name='char' size-in-bits='8' id='a84c031d'/>
	<array-type-def dimensions='1' type-id='a84c031d' size-in-bits='2048' id='d1617432'>
	- <subrange length='256' type-id='4c87fef4' id='36e5b9fa'/>
	+ <subrange length='256' type-id='7359adad' id='36e5b9fa'/>
	</array-type-def>
	<array-type-def dimensions='1' type-id='a84c031d' size-in-bits='32768' id='d16c6df4'>
	- <subrange length='4096' type-id='4c87fef4' id='bc1b5ddc'/>
	+ <subrange length='4096' type-id='7359adad' id='bc1b5ddc'/>
	</array-type-def>
	<array-type-def dimensions='1' type-id='a84c031d' size-in-bits='320' id='36c46961'>
	- <subrange length='40' type-id='4c87fef4' id='8f80b239'/>
	+ <subrange length='40' type-id='7359adad' id='8f80b239'/>
	</array-type-def>
	<array-type-def dimensions='1' type-id='a84c031d' size-in-bits='65536' id='163f6aa5'>
	- <subrange length='8192' type-id='4c87fef4' id='c88f397d'/>
	+ <subrange length='8192' type-id='7359adad' id='c88f397d'/>
	</array-type-def>
	<type-decl name='int' size-in-bits='32' id='95e97e5e'/>
	<type-decl name='long int' size-in-bits='64' id='bd54fe1a'/>
	<type-decl name='short int' size-in-bits='16' id='a2185560'/>
	- <type-decl name='sizetype' size-in-bits='64' id='4c87fef4'/>
	<array-type-def dimensions='1' type-id='9c313c2d' size-in-bits='128' id='c1c22e6c'>
	- <subrange length='2' type-id='4c87fef4' id='52efc4ef'/>
	+ <subrange length='2' type-id='7359adad' id='52efc4ef'/>
	</array-type-def>
	<array-type-def dimensions='1' type-id='9c313c2d' size-in-bits='2176' id='8c2bcad1'>
	- <subrange length='34' type-id='4c87fef4' id='6a6a7e00'/>
	+ <subrange length='34' type-id='7359adad' id='6a6a7e00'/>
	</array-type-def>
	<array-type-def dimensions='1' type-id='9c313c2d' size-in-bits='256' id='85c64d26'>
	- <subrange length='4' type-id='4c87fef4' id='16fe7105'/>
	+ <subrange length='4' type-id='7359adad' id='16fe7105'/>
	</array-type-def>
	<array-type-def dimensions='1' type-id='b96825af' size-in-bits='96' id='fa8ef949'>
	- <subrange length='12' type-id='4c87fef4' id='84827bdc'/>
	+ <subrange length='12' type-id='7359adad' id='84827bdc'/>
	</array-type-def>
	<array-type-def dimensions='1' type-id='b96825af' size-in-bits='128' id='fa9986a5'>
	- <subrange length='16' type-id='4c87fef4' id='848d0938'/>
	+ <subrange length='16' type-id='7359adad' id='848d0938'/>
	</array-type-def>
	<array-type-def dimensions='1' type-id='b96825af' size-in-bits='24' id='d3490169'>
	- <subrange length='3' type-id='4c87fef4' id='56f209d2'/>
	+ <subrange length='3' type-id='7359adad' id='56f209d2'/>
	</array-type-def>
	<array-type-def dimensions='1' type-id='b96825af' size-in-bits='40' id='0f4ddd0b'>
	- <subrange length='5' type-id='4c87fef4' id='53010e10'/>
	+ <subrange length='5' type-id='7359adad' id='53010e10'/>
	</array-type-def>
	<array-type-def dimensions='1' type-id='b96825af' size-in-bits='48' id='0f562bd0'>
	- <subrange length='6' type-id='4c87fef4' id='52fa524b'/>
	+ <subrange length='6' type-id='7359adad' id='52fa524b'/>
	</array-type-def>
	<array-type-def dimensions='1' type-id='b96825af' size-in-bits='64' id='13339fda'>
	- <subrange length='8' type-id='4c87fef4' id='56e0c0b1'/>
	+ <subrange length='8' type-id='7359adad' id='56e0c0b1'/>
	</array-type-def>
	<type-decl name='unnamed-enum-underlying-type-32' is-anonymous='yes' size-in-bits='32' alignment-in-bits='32' id='9cac1fee'/>
	<type-decl name='unsigned char' size-in-bits='8' id='002ac4a6'/>
	<type-decl name='unsigned int' size-in-bits='32' id='f0981eeb'/>
	<type-decl name='unsigned long int' size-in-bits='64' id='7359adad'/>
	<type-decl name='variadic parameter type' id='2c1145c5'/>
	<type-decl name='void' id='48b5725f'/>
	<enum-decl name='lzc_dataset_type' id='bc9887f1'>
	<underlying-type type-id='9cac1fee'/>
	<enumerator name='LZC_DATSET_TYPE_ZFS' value='2'/>
	<enumerator name='LZC_DATSET_TYPE_ZVOL' value='3'/>
	</enum-decl>
	- <typedef-decl name='nvlist_t' type-id='ac266fd9' id='8e8d4be3'/>
	+ <enum-decl name='lzc_send_flags' id='bfbd3c8e'>
	+ <underlying-type type-id='9cac1fee'/>
	+ <enumerator name='LZC_SEND_FLAG_EMBED_DATA' value='1'/>
	+ <enumerator name='LZC_SEND_FLAG_LARGE_BLOCK' value='2'/>
	+ <enumerator name='LZC_SEND_FLAG_COMPRESS' value='4'/>
	+ <enumerator name='LZC_SEND_FLAG_RAW' value='8'/>
	+ <enumerator name='LZC_SEND_FLAG_SAVED' value='16'/>
	+ </enum-decl>
	+ <class-decl name='ddt_key' size-in-bits='320' is-struct='yes' visibility='default' id='e0a4a1cb'>
	+ <data-member access='public' layout-offset-in-bits='0'>
	+ <var-decl name='ddk_cksum' type-id='39730d0b' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='256'>
	+ <var-decl name='ddk_prop' type-id='9c313c2d' visibility='default'/>
	+ </data-member>
	+ </class-decl>
	+ <typedef-decl name='ddt_key_t' type-id='e0a4a1cb' id='67f6d2cf'/>
	+ <enum-decl name='dmu_object_type' id='04b3b0b9'>
	+ <underlying-type type-id='9cac1fee'/>
	+ <enumerator name='DMU_OT_NONE' value='0'/>
	+ <enumerator name='DMU_OT_OBJECT_DIRECTORY' value='1'/>
	+ <enumerator name='DMU_OT_OBJECT_ARRAY' value='2'/>
	+ <enumerator name='DMU_OT_PACKED_NVLIST' value='3'/>
	+ <enumerator name='DMU_OT_PACKED_NVLIST_SIZE' value='4'/>
	+ <enumerator name='DMU_OT_BPOBJ' value='5'/>
	+ <enumerator name='DMU_OT_BPOBJ_HDR' value='6'/>
	+ <enumerator name='DMU_OT_SPACE_MAP_HEADER' value='7'/>
	+ <enumerator name='DMU_OT_SPACE_MAP' value='8'/>
	+ <enumerator name='DMU_OT_INTENT_LOG' value='9'/>
	+ <enumerator name='DMU_OT_DNODE' value='10'/>
	+ <enumerator name='DMU_OT_OBJSET' value='11'/>
	+ <enumerator name='DMU_OT_DSL_DIR' value='12'/>
	+ <enumerator name='DMU_OT_DSL_DIR_CHILD_MAP' value='13'/>
	+ <enumerator name='DMU_OT_DSL_DS_SNAP_MAP' value='14'/>
	+ <enumerator name='DMU_OT_DSL_PROPS' value='15'/>
	+ <enumerator name='DMU_OT_DSL_DATASET' value='16'/>
	+ <enumerator name='DMU_OT_ZNODE' value='17'/>
	+ <enumerator name='DMU_OT_OLDACL' value='18'/>
	+ <enumerator name='DMU_OT_PLAIN_FILE_CONTENTS' value='19'/>
	+ <enumerator name='DMU_OT_DIRECTORY_CONTENTS' value='20'/>
	+ <enumerator name='DMU_OT_MASTER_NODE' value='21'/>
	+ <enumerator name='DMU_OT_UNLINKED_SET' value='22'/>
	+ <enumerator name='DMU_OT_ZVOL' value='23'/>
	+ <enumerator name='DMU_OT_ZVOL_PROP' value='24'/>
	+ <enumerator name='DMU_OT_PLAIN_OTHER' value='25'/>
	+ <enumerator name='DMU_OT_UINT64_OTHER' value='26'/>
	+ <enumerator name='DMU_OT_ZAP_OTHER' value='27'/>
	+ <enumerator name='DMU_OT_ERROR_LOG' value='28'/>
	+ <enumerator name='DMU_OT_SPA_HISTORY' value='29'/>
	+ <enumerator name='DMU_OT_SPA_HISTORY_OFFSETS' value='30'/>
	+ <enumerator name='DMU_OT_POOL_PROPS' value='31'/>
	+ <enumerator name='DMU_OT_DSL_PERMS' value='32'/>
	+ <enumerator name='DMU_OT_ACL' value='33'/>
	+ <enumerator name='DMU_OT_SYSACL' value='34'/>
	+ <enumerator name='DMU_OT_FUID' value='35'/>
	+ <enumerator name='DMU_OT_FUID_SIZE' value='36'/>
	+ <enumerator name='DMU_OT_NEXT_CLONES' value='37'/>
	+ <enumerator name='DMU_OT_SCAN_QUEUE' value='38'/>
	+ <enumerator name='DMU_OT_USERGROUP_USED' value='39'/>
	+ <enumerator name='DMU_OT_USERGROUP_QUOTA' value='40'/>
	+ <enumerator name='DMU_OT_USERREFS' value='41'/>
	+ <enumerator name='DMU_OT_DDT_ZAP' value='42'/>
	+ <enumerator name='DMU_OT_DDT_STATS' value='43'/>
	+ <enumerator name='DMU_OT_SA' value='44'/>
	+ <enumerator name='DMU_OT_SA_MASTER_NODE' value='45'/>
	+ <enumerator name='DMU_OT_SA_ATTR_REGISTRATION' value='46'/>
	+ <enumerator name='DMU_OT_SA_ATTR_LAYOUTS' value='47'/>
	+ <enumerator name='DMU_OT_SCAN_XLATE' value='48'/>
	+ <enumerator name='DMU_OT_DEDUP' value='49'/>
	+ <enumerator name='DMU_OT_DEADLIST' value='50'/>
	+ <enumerator name='DMU_OT_DEADLIST_HDR' value='51'/>
	+ <enumerator name='DMU_OT_DSL_CLONES' value='52'/>
	+ <enumerator name='DMU_OT_BPOBJ_SUBOBJ' value='53'/>
	+ <enumerator name='DMU_OT_NUMTYPES' value='54'/>
	+ <enumerator name='DMU_OTN_UINT8_DATA' value='128'/>
	+ <enumerator name='DMU_OTN_UINT8_METADATA' value='192'/>
	+ <enumerator name='DMU_OTN_UINT16_DATA' value='129'/>
	+ <enumerator name='DMU_OTN_UINT16_METADATA' value='193'/>
	+ <enumerator name='DMU_OTN_UINT32_DATA' value='130'/>
	+ <enumerator name='DMU_OTN_UINT32_METADATA' value='194'/>
	+ <enumerator name='DMU_OTN_UINT64_DATA' value='131'/>
	+ <enumerator name='DMU_OTN_UINT64_METADATA' value='195'/>
	+ <enumerator name='DMU_OTN_ZAP_DATA' value='132'/>
	+ <enumerator name='DMU_OTN_ZAP_METADATA' value='196'/>
	+ <enumerator name='DMU_OTN_UINT8_ENC_DATA' value='160'/>
	+ <enumerator name='DMU_OTN_UINT8_ENC_METADATA' value='224'/>
	+ <enumerator name='DMU_OTN_UINT16_ENC_DATA' value='161'/>
	+ <enumerator name='DMU_OTN_UINT16_ENC_METADATA' value='225'/>
	+ <enumerator name='DMU_OTN_UINT32_ENC_DATA' value='162'/>
	+ <enumerator name='DMU_OTN_UINT32_ENC_METADATA' value='226'/>
	+ <enumerator name='DMU_OTN_UINT64_ENC_DATA' value='163'/>
	+ <enumerator name='DMU_OTN_UINT64_ENC_METADATA' value='227'/>
	+ <enumerator name='DMU_OTN_ZAP_ENC_DATA' value='164'/>
	+ <enumerator name='DMU_OTN_ZAP_ENC_METADATA' value='228'/>
	+ </enum-decl>
	+ <typedef-decl name='dmu_object_type_t' type-id='04b3b0b9' id='5c9d8906'/>
	+ <class-decl name='dmu_objset_stats' size-in-bits='2304' is-struct='yes' visibility='default' id='098f0221'>
	+ <data-member access='public' layout-offset-in-bits='0'>
	+ <var-decl name='dds_num_clones' type-id='9c313c2d' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='64'>
	+ <var-decl name='dds_creation_txg' type-id='9c313c2d' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='128'>
	+ <var-decl name='dds_guid' type-id='9c313c2d' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='192'>
	+ <var-decl name='dds_type' type-id='230f1e16' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='224'>
	+ <var-decl name='dds_is_snapshot' type-id='b96825af' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='232'>
	+ <var-decl name='dds_inconsistent' type-id='b96825af' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='240'>
	+ <var-decl name='dds_redacted' type-id='b96825af' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='248'>
	+ <var-decl name='dds_origin' type-id='d1617432' visibility='default'/>
	+ </data-member>
	+ </class-decl>
	+ <typedef-decl name='dmu_objset_stats_t' type-id='098f0221' id='b2c14f17'/>
	+ <enum-decl name='dmu_objset_type' id='6b1b19f9'>
	+ <underlying-type type-id='9cac1fee'/>
	+ <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='6b1b19f9' id='230f1e16'/>
	+ <enum-decl name='pool_initialize_func' id='5c246ad4'>
	+ <underlying-type type-id='9cac1fee'/>
	+ <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='5c246ad4' id='7063e1ab'/>
	+ <enum-decl name='pool_trim_func' id='54ed608a'>
	+ <underlying-type type-id='9cac1fee'/>
	+ <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='54ed608a' id='b1146b8d'/>
	+ <enum-decl name='zpool_wait_activity_t' naming-typedef-id='73446457' id='849338e3'>
	+ <underlying-type type-id='9cac1fee'/>
	+ <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='849338e3' id='73446457'/>
	+ <enum-decl name='zfs_wait_activity_t' naming-typedef-id='3024501a' id='527d5dc6'>
	+ <underlying-type type-id='9cac1fee'/>
	+ <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='527d5dc6' id='3024501a'/>
	+ <enum-decl name='data_type_t' naming-typedef-id='8d0687d2' id='aeeae136'>
	+ <underlying-type type-id='9cac1fee'/>
	+ <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='aeeae136' id='8d0687d2'/>
	+ <class-decl name='nvpair' size-in-bits='128' is-struct='yes' visibility='default' id='1c34e459'>
	+ <data-member access='public' layout-offset-in-bits='0'>
	+ <var-decl name='nvp_size' type-id='3ff5601b' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='32'>
	+ <var-decl name='nvp_name_sz' type-id='23bd8cb5' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='48'>
	+ <var-decl name='nvp_reserve' type-id='23bd8cb5' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='64'>
	+ <var-decl name='nvp_value_elem' type-id='3ff5601b' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='96'>
	+ <var-decl name='nvp_type' type-id='8d0687d2' visibility='default'/>
	+ </data-member>
	+ </class-decl>
	+ <typedef-decl name='nvpair_t' type-id='1c34e459' id='57928edf'/>
	<class-decl name='nvlist' size-in-bits='192' is-struct='yes' visibility='default' id='ac266fd9'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='nvl_version' type-id='3ff5601b' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='32'>
	<var-decl name='nvl_nvflag' type-id='8f92235e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='nvl_priv' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='nvl_flag' type-id='8f92235e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='160'>
	<var-decl name='nvl_pad' type-id='3ff5601b' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='int32_t' type-id='95e97e5e' id='3ff5601b'/>
	- <typedef-decl name='uint32_t' type-id='f0981eeb' id='8f92235e'/>
	- <typedef-decl name='uint64_t' type-id='7359adad' id='9c313c2d'/>
	- <typedef-decl name='uint8_t' type-id='002ac4a6' id='b96825af'/>
	- <typedef-decl name='uint_t' type-id='f0981eeb' id='3502e3ff'/>
	- <typedef-decl name='boolean_t' type-id='08f5ca17' id='c19b74c3'/>
	- <enum-decl name='__anonymous_enum__' is-anonymous='yes' id='08f5ca17'>
	- <underlying-type type-id='9cac1fee'/>
	- <enumerator name='B_FALSE' value='0'/>
	- <enumerator name='B_TRUE' value='1'/>
	- </enum-decl>
	- <enum-decl name='lzc_send_flags' id='bfbd3c8e'>
	- <underlying-type type-id='9cac1fee'/>
	- <enumerator name='LZC_SEND_FLAG_EMBED_DATA' value='1'/>
	- <enumerator name='LZC_SEND_FLAG_LARGE_BLOCK' value='2'/>
	- <enumerator name='LZC_SEND_FLAG_COMPRESS' value='4'/>
	- <enumerator name='LZC_SEND_FLAG_RAW' value='8'/>
	- <enumerator name='LZC_SEND_FLAG_SAVED' value='16'/>
	- </enum-decl>
	- <typedef-decl name='dmu_replay_record_t' type-id='781a52d7' id='8b8fc893'/>
	+ <typedef-decl name='nvlist_t' type-id='ac266fd9' id='8e8d4be3'/>
	+ <class-decl name='zio_cksum' size-in-bits='256' is-struct='yes' visibility='default' id='1d53e28b'>
	+ <data-member access='public' layout-offset-in-bits='0'>
	+ <var-decl name='zc_word' type-id='85c64d26' visibility='default'/>
	+ </data-member>
	+ </class-decl>
	+ <typedef-decl name='zio_cksum_t' type-id='1d53e28b' id='39730d0b'/>
	+ <class-decl name='drr_begin' size-in-bits='2432' is-struct='yes' visibility='default' id='09fcdc01'>
	+ <data-member access='public' layout-offset-in-bits='0'>
	+ <var-decl name='drr_magic' type-id='9c313c2d' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='64'>
	+ <var-decl name='drr_versioninfo' type-id='9c313c2d' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='128'>
	+ <var-decl name='drr_creation_time' type-id='9c313c2d' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='192'>
	+ <var-decl name='drr_type' type-id='230f1e16' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='224'>
	+ <var-decl name='drr_flags' type-id='8f92235e' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='256'>
	+ <var-decl name='drr_toguid' type-id='9c313c2d' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='320'>
	+ <var-decl name='drr_fromguid' type-id='9c313c2d' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='384'>
	+ <var-decl name='drr_toname' type-id='d1617432' visibility='default'/>
	+ </data-member>
	+ </class-decl>
	<class-decl name='dmu_replay_record' size-in-bits='2496' is-struct='yes' visibility='default' id='781a52d7'>
	<data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='drr_type' type-id='40ed39d2' visibility='default'/>
	+ <var-decl name='drr_type' type-id='08f5ca17' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='32'>
	<var-decl name='drr_payloadlen' type-id='8f92235e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='drr_u' type-id='edc8c94a' visibility='default'/>
	+ <var-decl name='drr_u' type-id='ac5ab597' visibility='default'/>
	</data-member>
	</class-decl>
	- <enum-decl name='__anonymous_enum__1' is-anonymous='yes' id='40ed39d2'>
	+ <enum-decl name='__anonymous_enum__' is-anonymous='yes' id='08f5ca17'>
	<underlying-type type-id='9cac1fee'/>
	<enumerator name='DRR_BEGIN' value='0'/>
	<enumerator name='DRR_OBJECT' value='1'/>
	<enumerator name='DRR_FREEOBJECTS' value='2'/>
	<enumerator name='DRR_WRITE' value='3'/>
	<enumerator name='DRR_FREE' value='4'/>
	<enumerator name='DRR_END' value='5'/>
	<enumerator name='DRR_WRITE_BYREF' value='6'/>
	<enumerator name='DRR_SPILL' value='7'/>
	<enumerator name='DRR_WRITE_EMBEDDED' value='8'/>
	<enumerator name='DRR_OBJECT_RANGE' value='9'/>
	<enumerator name='DRR_REDACT' value='10'/>
	<enumerator name='DRR_NUMTYPES' value='11'/>
	</enum-decl>
	- <union-decl name='__anonymous_union__' size-in-bits='2432' is-anonymous='yes' visibility='default' id='edc8c94a'>
	- <data-member access='private'>
	+ <union-decl name='__anonymous_union__' size-in-bits='2432' is-anonymous='yes' visibility='default' id='ac5ab597'>
	+ <data-member access='public'>
	<var-decl name='drr_begin' type-id='09fcdc01' visibility='default'/>
	</data-member>
	- <data-member access='private'>
	+ <data-member access='public'>
	<var-decl name='drr_end' type-id='6ee25631' visibility='default'/>
	</data-member>
	- <data-member access='private'>
	+ <data-member access='public'>
	<var-decl name='drr_object' type-id='f9ad530b' visibility='default'/>
	</data-member>
	- <data-member access='private'>
	+ <data-member access='public'>
	<var-decl name='drr_freeobjects' type-id='a27d958e' visibility='default'/>
	</data-member>
	- <data-member access='private'>
	+ <data-member access='public'>
	<var-decl name='drr_write' type-id='4cc69e4b' visibility='default'/>
	</data-member>
	- <data-member access='private'>
	+ <data-member access='public'>
	<var-decl name='drr_free' type-id='c836cfd2' visibility='default'/>
	</data-member>
	- <data-member access='private'>
	+ <data-member access='public'>
	<var-decl name='drr_write_byref' type-id='e511cdce' visibility='default'/>
	</data-member>
	- <data-member access='private'>
	+ <data-member access='public'>
	<var-decl name='drr_spill' type-id='1e69a80a' visibility='default'/>
	</data-member>
	- <data-member access='private'>
	+ <data-member access='public'>
	<var-decl name='drr_write_embedded' type-id='98b1345e' visibility='default'/>
	</data-member>
	- <data-member access='private'>
	+ <data-member access='public'>
	<var-decl name='drr_object_range' type-id='aba1f9e1' visibility='default'/>
	</data-member>
	- <data-member access='private'>
	+ <data-member access='public'>
	<var-decl name='drr_redact' type-id='50389039' visibility='default'/>
	</data-member>
	- <data-member access='private'>
	+ <data-member access='public'>
	<var-decl name='drr_checksum' type-id='a5fe3647' visibility='default'/>
	</data-member>
	</union-decl>
	- <class-decl name='drr_begin' size-in-bits='2432' is-struct='yes' visibility='default' id='09fcdc01'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='drr_magic' type-id='9c313c2d' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='drr_versioninfo' type-id='9c313c2d' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='drr_creation_time' type-id='9c313c2d' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='192'>
	- <var-decl name='drr_type' type-id='230f1e16' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='224'>
	- <var-decl name='drr_flags' type-id='8f92235e' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='256'>
	- <var-decl name='drr_toguid' type-id='9c313c2d' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='320'>
	- <var-decl name='drr_fromguid' type-id='9c313c2d' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='384'>
	- <var-decl name='drr_toname' type-id='d1617432' visibility='default'/>
	- </data-member>
	- </class-decl>
	- <typedef-decl name='dmu_objset_type_t' type-id='6b1b19f9' id='230f1e16'/>
	- <enum-decl name='dmu_objset_type' id='6b1b19f9'>
	- <underlying-type type-id='9cac1fee'/>
	- <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>
	<class-decl name='drr_end' size-in-bits='320' is-struct='yes' visibility='default' id='6ee25631'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='drr_checksum' type-id='39730d0b' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='256'>
	<var-decl name='drr_toguid' type-id='9c313c2d' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='zio_cksum_t' type-id='1d53e28b' id='39730d0b'/>
	- <class-decl name='zio_cksum' size-in-bits='256' is-struct='yes' visibility='default' id='1d53e28b'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='zc_word' type-id='85c64d26' visibility='default'/>
	- </data-member>
	- </class-decl>
	<class-decl name='drr_object' size-in-bits='448' is-struct='yes' visibility='default' id='f9ad530b'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='drr_object' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='drr_type' type-id='5c9d8906' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='96'>
	<var-decl name='drr_bonustype' type-id='5c9d8906' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='drr_blksz' type-id='8f92235e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='160'>
	<var-decl name='drr_bonuslen' type-id='8f92235e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	<var-decl name='drr_checksumtype' type-id='b96825af' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='200'>
	<var-decl name='drr_compress' type-id='b96825af' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='208'>
	<var-decl name='drr_dn_slots' type-id='b96825af' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='216'>
	<var-decl name='drr_flags' type-id='b96825af' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='224'>
	<var-decl name='drr_raw_bonuslen' type-id='8f92235e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='256'>
	<var-decl name='drr_toguid' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='320'>
	<var-decl name='drr_indblkshift' type-id='b96825af' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='328'>
	<var-decl name='drr_nlevels' type-id='b96825af' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='336'>
	<var-decl name='drr_nblkptr' type-id='b96825af' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='344'>
	<var-decl name='drr_pad' type-id='0f4ddd0b' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='384'>
	<var-decl name='drr_maxblkid' type-id='9c313c2d' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='dmu_object_type_t' type-id='04b3b0b9' id='5c9d8906'/>
	- <enum-decl name='dmu_object_type' id='04b3b0b9'>
	- <underlying-type type-id='9cac1fee'/>
	- <enumerator name='DMU_OT_NONE' value='0'/>
	- <enumerator name='DMU_OT_OBJECT_DIRECTORY' value='1'/>
	- <enumerator name='DMU_OT_OBJECT_ARRAY' value='2'/>
	- <enumerator name='DMU_OT_PACKED_NVLIST' value='3'/>
	- <enumerator name='DMU_OT_PACKED_NVLIST_SIZE' value='4'/>
	- <enumerator name='DMU_OT_BPOBJ' value='5'/>
	- <enumerator name='DMU_OT_BPOBJ_HDR' value='6'/>
	- <enumerator name='DMU_OT_SPACE_MAP_HEADER' value='7'/>
	- <enumerator name='DMU_OT_SPACE_MAP' value='8'/>
	- <enumerator name='DMU_OT_INTENT_LOG' value='9'/>
	- <enumerator name='DMU_OT_DNODE' value='10'/>
	- <enumerator name='DMU_OT_OBJSET' value='11'/>
	- <enumerator name='DMU_OT_DSL_DIR' value='12'/>
	- <enumerator name='DMU_OT_DSL_DIR_CHILD_MAP' value='13'/>
	- <enumerator name='DMU_OT_DSL_DS_SNAP_MAP' value='14'/>
	- <enumerator name='DMU_OT_DSL_PROPS' value='15'/>
	- <enumerator name='DMU_OT_DSL_DATASET' value='16'/>
	- <enumerator name='DMU_OT_ZNODE' value='17'/>
	- <enumerator name='DMU_OT_OLDACL' value='18'/>
	- <enumerator name='DMU_OT_PLAIN_FILE_CONTENTS' value='19'/>
	- <enumerator name='DMU_OT_DIRECTORY_CONTENTS' value='20'/>
	- <enumerator name='DMU_OT_MASTER_NODE' value='21'/>
	- <enumerator name='DMU_OT_UNLINKED_SET' value='22'/>
	- <enumerator name='DMU_OT_ZVOL' value='23'/>
	- <enumerator name='DMU_OT_ZVOL_PROP' value='24'/>
	- <enumerator name='DMU_OT_PLAIN_OTHER' value='25'/>
	- <enumerator name='DMU_OT_UINT64_OTHER' value='26'/>
	- <enumerator name='DMU_OT_ZAP_OTHER' value='27'/>
	- <enumerator name='DMU_OT_ERROR_LOG' value='28'/>
	- <enumerator name='DMU_OT_SPA_HISTORY' value='29'/>
	- <enumerator name='DMU_OT_SPA_HISTORY_OFFSETS' value='30'/>
	- <enumerator name='DMU_OT_POOL_PROPS' value='31'/>
	- <enumerator name='DMU_OT_DSL_PERMS' value='32'/>
	- <enumerator name='DMU_OT_ACL' value='33'/>
	- <enumerator name='DMU_OT_SYSACL' value='34'/>
	- <enumerator name='DMU_OT_FUID' value='35'/>
	- <enumerator name='DMU_OT_FUID_SIZE' value='36'/>
	- <enumerator name='DMU_OT_NEXT_CLONES' value='37'/>
	- <enumerator name='DMU_OT_SCAN_QUEUE' value='38'/>
	- <enumerator name='DMU_OT_USERGROUP_USED' value='39'/>
	- <enumerator name='DMU_OT_USERGROUP_QUOTA' value='40'/>
	- <enumerator name='DMU_OT_USERREFS' value='41'/>
	- <enumerator name='DMU_OT_DDT_ZAP' value='42'/>
	- <enumerator name='DMU_OT_DDT_STATS' value='43'/>
	- <enumerator name='DMU_OT_SA' value='44'/>
	- <enumerator name='DMU_OT_SA_MASTER_NODE' value='45'/>
	- <enumerator name='DMU_OT_SA_ATTR_REGISTRATION' value='46'/>
	- <enumerator name='DMU_OT_SA_ATTR_LAYOUTS' value='47'/>
	- <enumerator name='DMU_OT_SCAN_XLATE' value='48'/>
	- <enumerator name='DMU_OT_DEDUP' value='49'/>
	- <enumerator name='DMU_OT_DEADLIST' value='50'/>
	- <enumerator name='DMU_OT_DEADLIST_HDR' value='51'/>
	- <enumerator name='DMU_OT_DSL_CLONES' value='52'/>
	- <enumerator name='DMU_OT_BPOBJ_SUBOBJ' value='53'/>
	- <enumerator name='DMU_OT_NUMTYPES' value='54'/>
	- <enumerator name='DMU_OTN_UINT8_DATA' value='128'/>
	- <enumerator name='DMU_OTN_UINT8_METADATA' value='192'/>
	- <enumerator name='DMU_OTN_UINT16_DATA' value='129'/>
	- <enumerator name='DMU_OTN_UINT16_METADATA' value='193'/>
	- <enumerator name='DMU_OTN_UINT32_DATA' value='130'/>
	- <enumerator name='DMU_OTN_UINT32_METADATA' value='194'/>
	- <enumerator name='DMU_OTN_UINT64_DATA' value='131'/>
	- <enumerator name='DMU_OTN_UINT64_METADATA' value='195'/>
	- <enumerator name='DMU_OTN_ZAP_DATA' value='132'/>
	- <enumerator name='DMU_OTN_ZAP_METADATA' value='196'/>
	- <enumerator name='DMU_OTN_UINT8_ENC_DATA' value='160'/>
	- <enumerator name='DMU_OTN_UINT8_ENC_METADATA' value='224'/>
	- <enumerator name='DMU_OTN_UINT16_ENC_DATA' value='161'/>
	- <enumerator name='DMU_OTN_UINT16_ENC_METADATA' value='225'/>
	- <enumerator name='DMU_OTN_UINT32_ENC_DATA' value='162'/>
	- <enumerator name='DMU_OTN_UINT32_ENC_METADATA' value='226'/>
	- <enumerator name='DMU_OTN_UINT64_ENC_DATA' value='163'/>
	- <enumerator name='DMU_OTN_UINT64_ENC_METADATA' value='227'/>
	- <enumerator name='DMU_OTN_ZAP_ENC_DATA' value='164'/>
	- <enumerator name='DMU_OTN_ZAP_ENC_METADATA' value='228'/>
	- </enum-decl>
	<class-decl name='drr_freeobjects' size-in-bits='192' is-struct='yes' visibility='default' id='a27d958e'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='drr_firstobj' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='drr_numobjs' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='drr_toguid' type-id='9c313c2d' visibility='default'/>
	</data-member>
	</class-decl>
	<class-decl name='drr_write' size-in-bits='1088' is-struct='yes' visibility='default' id='4cc69e4b'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='drr_object' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='drr_type' type-id='5c9d8906' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='96'>
	<var-decl name='drr_pad' type-id='8f92235e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='drr_offset' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	<var-decl name='drr_logical_size' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='256'>
	<var-decl name='drr_toguid' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='320'>
	<var-decl name='drr_checksumtype' type-id='b96825af' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='328'>
	<var-decl name='drr_flags' type-id='b96825af' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='336'>
	<var-decl name='drr_compressiontype' type-id='b96825af' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='344'>
	<var-decl name='drr_pad2' type-id='0f4ddd0b' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='384'>
	<var-decl name='drr_key' type-id='67f6d2cf' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='704'>
	<var-decl name='drr_compressed_size' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='768'>
	<var-decl name='drr_salt' type-id='13339fda' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='832'>
	<var-decl name='drr_iv' type-id='fa8ef949' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='928'>
	<var-decl name='drr_mac' type-id='fa9986a5' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='ddt_key_t' type-id='e0a4a1cb' id='67f6d2cf'/>
	- <class-decl name='ddt_key' size-in-bits='320' is-struct='yes' visibility='default' id='e0a4a1cb'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='ddk_cksum' type-id='39730d0b' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='256'>
	- <var-decl name='ddk_prop' type-id='9c313c2d' visibility='default'/>
	- </data-member>
	- </class-decl>
	<class-decl name='drr_free' size-in-bits='256' is-struct='yes' visibility='default' id='c836cfd2'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='drr_object' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='drr_offset' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='drr_length' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	<var-decl name='drr_toguid' type-id='9c313c2d' visibility='default'/>
	</data-member>
	</class-decl>
	<class-decl name='drr_write_byref' size-in-bits='832' is-struct='yes' visibility='default' id='e511cdce'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='drr_object' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='drr_offset' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='drr_length' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	<var-decl name='drr_toguid' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='256'>
	<var-decl name='drr_refguid' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='320'>
	<var-decl name='drr_refobject' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='384'>
	<var-decl name='drr_refoffset' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='448'>
	<var-decl name='drr_checksumtype' type-id='b96825af' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='456'>
	<var-decl name='drr_flags' type-id='b96825af' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='464'>
	<var-decl name='drr_pad2' type-id='0f562bd0' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='512'>
	<var-decl name='drr_key' type-id='67f6d2cf' visibility='default'/>
	</data-member>
	</class-decl>
	<class-decl name='drr_spill' size-in-bits='640' is-struct='yes' visibility='default' id='1e69a80a'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='drr_object' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='drr_length' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='drr_toguid' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	<var-decl name='drr_flags' type-id='b96825af' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='200'>
	<var-decl name='drr_compressiontype' type-id='b96825af' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='208'>
	<var-decl name='drr_pad' type-id='0f562bd0' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='256'>
	<var-decl name='drr_compressed_size' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='320'>
	<var-decl name='drr_salt' type-id='13339fda' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='384'>
	<var-decl name='drr_iv' type-id='fa8ef949' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='480'>
	<var-decl name='drr_mac' type-id='fa9986a5' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='608'>
	<var-decl name='drr_type' type-id='5c9d8906' visibility='default'/>
	</data-member>
	</class-decl>
	<class-decl name='drr_write_embedded' size-in-bits='384' is-struct='yes' visibility='default' id='98b1345e'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='drr_object' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='drr_offset' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='drr_length' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	<var-decl name='drr_toguid' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='256'>
	<var-decl name='drr_compression' type-id='b96825af' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='264'>
	<var-decl name='drr_etype' type-id='b96825af' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='272'>
	<var-decl name='drr_pad' type-id='0f562bd0' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='320'>
	<var-decl name='drr_lsize' type-id='8f92235e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='352'>
	<var-decl name='drr_psize' type-id='8f92235e' visibility='default'/>
	</data-member>
	</class-decl>
	<class-decl name='drr_object_range' size-in-bits='512' is-struct='yes' visibility='default' id='aba1f9e1'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='drr_firstobj' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='drr_numslots' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='drr_toguid' type-id='9c313c2d' visibility='default'/>
	+ <var-decl name='drr_toguid' type-id='9c313c2d' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='192'>
	+ <var-decl name='drr_salt' type-id='13339fda' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='256'>
	+ <var-decl name='drr_iv' type-id='fa8ef949' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='352'>
	+ <var-decl name='drr_mac' type-id='fa9986a5' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='480'>
	+ <var-decl name='drr_flags' type-id='b96825af' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='488'>
	+ <var-decl name='drr_pad' type-id='d3490169' visibility='default'/>
	+ </data-member>
	+ </class-decl>
	+ <class-decl name='drr_redact' size-in-bits='256' is-struct='yes' visibility='default' id='50389039'>
	+ <data-member access='public' layout-offset-in-bits='0'>
	+ <var-decl name='drr_object' type-id='9c313c2d' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='64'>
	+ <var-decl name='drr_offset' type-id='9c313c2d' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='128'>
	+ <var-decl name='drr_length' type-id='9c313c2d' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='192'>
	+ <var-decl name='drr_toguid' type-id='9c313c2d' visibility='default'/>
	+ </data-member>
	+ </class-decl>
	+ <class-decl name='drr_checksum' size-in-bits='2432' is-struct='yes' visibility='default' id='a5fe3647'>
	+ <data-member access='public' layout-offset-in-bits='0'>
	+ <var-decl name='drr_pad' type-id='8c2bcad1' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='2176'>
	+ <var-decl name='drr_checksum' type-id='39730d0b' visibility='default'/>
	+ </data-member>
	+ </class-decl>
	+ <typedef-decl name='dmu_replay_record_t' type-id='781a52d7' id='8b8fc893'/>
	+ <class-decl name='zinject_record' size-in-bits='2816' is-struct='yes' visibility='default' id='3216f820'>
	+ <data-member access='public' layout-offset-in-bits='0'>
	+ <var-decl name='zi_objset' type-id='9c313c2d' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='64'>
	+ <var-decl name='zi_object' type-id='9c313c2d' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='128'>
	+ <var-decl name='zi_start' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	- <var-decl name='drr_salt' type-id='13339fda' visibility='default'/>
	+ <var-decl name='zi_end' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='256'>
	- <var-decl name='drr_iv' type-id='fa8ef949' visibility='default'/>
	+ <var-decl name='zi_guid' type-id='9c313c2d' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='320'>
	+ <var-decl name='zi_level' type-id='8f92235e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='352'>
	- <var-decl name='drr_mac' type-id='fa9986a5' visibility='default'/>
	+ <var-decl name='zi_error' type-id='8f92235e' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='384'>
	+ <var-decl name='zi_type' type-id='9c313c2d' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='448'>
	+ <var-decl name='zi_freq' type-id='8f92235e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='480'>
	- <var-decl name='drr_flags' type-id='b96825af' visibility='default'/>
	+ <var-decl name='zi_failfast' type-id='8f92235e' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='488'>
	- <var-decl name='drr_pad' type-id='d3490169' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='512'>
	+ <var-decl name='zi_func' type-id='d1617432' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='2560'>
	+ <var-decl name='zi_iotype' type-id='8f92235e' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='2592'>
	+ <var-decl name='zi_duration' type-id='3ff5601b' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='2624'>
	+ <var-decl name='zi_timer' type-id='9c313c2d' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='2688'>
	+ <var-decl name='zi_nlanes' type-id='9c313c2d' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='2752'>
	+ <var-decl name='zi_cmd' type-id='8f92235e' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='2784'>
	+ <var-decl name='zi_dvas' type-id='8f92235e' visibility='default'/>
	</data-member>
	</class-decl>
	- <class-decl name='drr_redact' size-in-bits='256' is-struct='yes' visibility='default' id='50389039'>
	+ <typedef-decl name='zinject_record_t' type-id='3216f820' id='a4301ca6'/>
	+ <class-decl name='zfs_share' size-in-bits='256' is-struct='yes' visibility='default' id='feb6f2da'>
	<data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='drr_object' type-id='9c313c2d' visibility='default'/>
	+ <var-decl name='z_exportdata' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='drr_offset' type-id='9c313c2d' visibility='default'/>
	+ <var-decl name='z_sharedata' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='drr_length' type-id='9c313c2d' visibility='default'/>
	+ <var-decl name='z_sharetype' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	- <var-decl name='drr_toguid' type-id='9c313c2d' visibility='default'/>
	- </data-member>
	- </class-decl>
	- <class-decl name='drr_checksum' size-in-bits='2432' is-struct='yes' visibility='default' id='a5fe3647'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='drr_pad' type-id='8c2bcad1' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='2176'>
	- <var-decl name='drr_checksum' type-id='39730d0b' visibility='default'/>
	+ <var-decl name='z_sharemax' type-id='9c313c2d' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='pool_initialize_func_t' type-id='5c246ad4' id='7063e1ab'/>
	- <enum-decl name='pool_initialize_func' id='5c246ad4'>
	- <underlying-type type-id='9cac1fee'/>
	- <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_trim_func_t' type-id='54ed608a' id='b1146b8d'/>
	- <enum-decl name='pool_trim_func' id='54ed608a'>
	- <underlying-type type-id='9cac1fee'/>
	- <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='zpool_wait_activity_t' type-id='3fed383f' id='73446457'/>
	- <enum-decl name='__anonymous_enum__2' is-anonymous='yes' id='3fed383f'>
	- <underlying-type type-id='9cac1fee'/>
	- <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='zfs_wait_activity_t' type-id='3eed36ac' id='3024501a'/>
	- <enum-decl name='__anonymous_enum__3' is-anonymous='yes' id='3eed36ac'>
	- <underlying-type type-id='9cac1fee'/>
	- <enumerator name='ZFS_WAIT_DELETEQ' value='0'/>
	- <enumerator name='ZFS_WAIT_NUM_ACTIVITIES' value='1'/>
	- </enum-decl>
	- <typedef-decl name='size_t' type-id='7359adad' id='b59d7dce'/>
	+ <typedef-decl name='zfs_share_t' type-id='feb6f2da' id='ee5cec36'/>
	<class-decl name='zfs_cmd' size-in-bits='109952' is-struct='yes' visibility='default' id='3522cd69'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='zc_name' type-id='d16c6df4' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='32768'>
	<var-decl name='zc_nvlist_src' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='32832'>
	<var-decl name='zc_nvlist_src_size' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='32896'>
	<var-decl name='zc_nvlist_dst' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='32960'>
	<var-decl name='zc_nvlist_dst_size' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='33024'>
	<var-decl name='zc_nvlist_dst_filled' type-id='c19b74c3' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='33056'>
	<var-decl name='zc_pad2' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='33088'>
	<var-decl name='zc_history' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='33152'>
	<var-decl name='zc_value' type-id='163f6aa5' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='98688'>
	<var-decl name='zc_string' type-id='d1617432' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='100736'>
	<var-decl name='zc_guid' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='100800'>
	<var-decl name='zc_nvlist_conf' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='100864'>
	<var-decl name='zc_nvlist_conf_size' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='100928'>
	<var-decl name='zc_cookie' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='100992'>
	<var-decl name='zc_objset_type' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='101056'>
	<var-decl name='zc_perm_action' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='101120'>
	<var-decl name='zc_history_len' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='101184'>
	<var-decl name='zc_history_offset' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='101248'>
	<var-decl name='zc_obj' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='101312'>
	<var-decl name='zc_iflags' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='101376'>
	<var-decl name='zc_share' type-id='ee5cec36' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='101632'>
	<var-decl name='zc_objset_stats' type-id='b2c14f17' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='103936'>
	<var-decl name='zc_begin_record' type-id='09fcdc01' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='106368'>
	<var-decl name='zc_inject_record' type-id='a4301ca6' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='109184'>
	<var-decl name='zc_defer_destroy' type-id='8f92235e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='109216'>
	<var-decl name='zc_flags' type-id='8f92235e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='109248'>
	<var-decl name='zc_action_handle' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='109312'>
	<var-decl name='zc_cleanup_fd' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='109344'>
	<var-decl name='zc_simple' type-id='b96825af' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='109352'>
	<var-decl name='zc_pad' type-id='d3490169' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='109376'>
	<var-decl name='zc_sendobj' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='109440'>
	<var-decl name='zc_fromobj' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='109504'>
	<var-decl name='zc_createtxg' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='109568'>
	<var-decl name='zc_stat' type-id='0371a9c7' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='109888'>
	<var-decl name='zc_zoneid' type-id='9c313c2d' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='zfs_share_t' type-id='feb6f2da' id='ee5cec36'/>
	- <class-decl name='zfs_share' size-in-bits='256' is-struct='yes' visibility='default' id='feb6f2da'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='z_exportdata' type-id='9c313c2d' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='z_sharedata' type-id='9c313c2d' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='z_sharetype' type-id='9c313c2d' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='192'>
	- <var-decl name='z_sharemax' type-id='9c313c2d' visibility='default'/>
	- </data-member>
	- </class-decl>
	- <typedef-decl name='dmu_objset_stats_t' type-id='098f0221' id='b2c14f17'/>
	- <class-decl name='dmu_objset_stats' size-in-bits='2304' is-struct='yes' visibility='default' id='098f0221'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='dds_num_clones' type-id='9c313c2d' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='dds_creation_txg' type-id='9c313c2d' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='dds_guid' type-id='9c313c2d' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='192'>
	- <var-decl name='dds_type' type-id='230f1e16' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='224'>
	- <var-decl name='dds_is_snapshot' type-id='b96825af' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='232'>
	- <var-decl name='dds_inconsistent' type-id='b96825af' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='240'>
	- <var-decl name='dds_redacted' type-id='b96825af' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='248'>
	- <var-decl name='dds_origin' type-id='d1617432' visibility='default'/>
	- </data-member>
	- </class-decl>
	- <typedef-decl name='zinject_record_t' type-id='3216f820' id='a4301ca6'/>
	- <class-decl name='zinject_record' size-in-bits='2816' is-struct='yes' visibility='default' id='3216f820'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='zi_objset' type-id='9c313c2d' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='zi_object' type-id='9c313c2d' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='zi_start' type-id='9c313c2d' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='192'>
	- <var-decl name='zi_end' type-id='9c313c2d' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='256'>
	- <var-decl name='zi_guid' type-id='9c313c2d' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='320'>
	- <var-decl name='zi_level' type-id='8f92235e' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='352'>
	- <var-decl name='zi_error' type-id='8f92235e' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='384'>
	- <var-decl name='zi_type' type-id='9c313c2d' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='448'>
	- <var-decl name='zi_freq' type-id='8f92235e' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='480'>
	- <var-decl name='zi_failfast' type-id='8f92235e' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='512'>
	- <var-decl name='zi_func' type-id='d1617432' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='2560'>
	- <var-decl name='zi_iotype' type-id='8f92235e' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='2592'>
	- <var-decl name='zi_duration' type-id='3ff5601b' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='2624'>
	- <var-decl name='zi_timer' type-id='9c313c2d' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='2688'>
	- <var-decl name='zi_nlanes' type-id='9c313c2d' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='2752'>
	- <var-decl name='zi_cmd' type-id='8f92235e' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='2784'>
	- <var-decl name='zi_dvas' type-id='8f92235e' visibility='default'/>
	- </data-member>
	- </class-decl>
	- <typedef-decl name='zfs_stat_t' type-id='6417f0b9' id='0371a9c7'/>
	<class-decl name='zfs_stat' size-in-bits='320' is-struct='yes' visibility='default' id='6417f0b9'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='zs_gen' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='zs_mode' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='zs_links' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	<var-decl name='zs_ctime' type-id='c1c22e6c' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='pthread_mutex_t' type-id='c4794498' id='7a6844eb'/>
	- <union-decl name='__anonymous_union__1' size-in-bits='320' is-anonymous='yes' visibility='default' id='c4794498'>
	- <data-member access='private'>
	+ <typedef-decl name='zfs_stat_t' type-id='6417f0b9' id='0371a9c7'/>
	+ <enum-decl name='boolean_t' naming-typedef-id='c19b74c3' id='f58c8277'>
	+ <underlying-type type-id='9cac1fee'/>
	+ <enumerator name='B_FALSE' value='0'/>
	+ <enumerator name='B_TRUE' value='1'/>
	+ </enum-decl>
	+ <typedef-decl name='boolean_t' type-id='f58c8277' id='c19b74c3'/>
	+ <typedef-decl name='uchar_t' type-id='002ac4a6' id='d8bf0010'/>
	+ <typedef-decl name='uint_t' type-id='f0981eeb' id='3502e3ff'/>
	+ <union-decl name='pthread_mutex_t' size-in-bits='320' naming-typedef-id='7a6844eb' visibility='default' id='70681f9b'>
	+ <data-member access='public'>
	<var-decl name='__data' type-id='4c734837' visibility='default'/>
	</data-member>
	- <data-member access='private'>
	+ <data-member access='public'>
	<var-decl name='__size' type-id='36c46961' visibility='default'/>
	</data-member>
	- <data-member access='private'>
	+ <data-member access='public'>
	<var-decl name='__align' type-id='bd54fe1a' visibility='default'/>
	</data-member>
	</union-decl>
	+ <typedef-decl name='pthread_mutex_t' type-id='70681f9b' id='7a6844eb'/>
	+ <typedef-decl name='int16_t' type-id='03896e23' id='23bd8cb5'/>
	+ <typedef-decl name='int32_t' type-id='33f57a65' id='3ff5601b'/>
	+ <typedef-decl name='uint8_t' type-id='c51d6389' id='b96825af'/>
	+ <typedef-decl name='uint32_t' type-id='62f1140c' id='8f92235e'/>
	+ <typedef-decl name='uint64_t' type-id='8910171f' id='9c313c2d'/>
	<class-decl name='__pthread_mutex_s' size-in-bits='320' is-struct='yes' visibility='default' id='4c734837'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='__lock' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='32'>
	<var-decl name='__count' type-id='f0981eeb' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='__owner' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='96'>
	<var-decl name='__nusers' type-id='f0981eeb' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='__kind' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='160'>
	<var-decl name='__spins' type-id='a2185560' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='176'>
	<var-decl name='__elision' type-id='a2185560' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	<var-decl name='__list' type-id='518fb49c' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='__pthread_list_t' type-id='0e01899c' id='518fb49c'/>
	<class-decl name='__pthread_internal_list' size-in-bits='128' is-struct='yes' visibility='default' id='0e01899c'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='__prev' type-id='4d98cd5a' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='__next' type-id='4d98cd5a' visibility='default'/>
	- </data-member>
	- </class-decl>
	- <typedef-decl name='nvpair_t' type-id='1c34e459' id='57928edf'/>
	- <class-decl name='nvpair' size-in-bits='128' is-struct='yes' visibility='default' id='1c34e459'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='nvp_size' type-id='3ff5601b' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='32'>
	- <var-decl name='nvp_name_sz' type-id='23bd8cb5' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='48'>
	- <var-decl name='nvp_reserve' type-id='23bd8cb5' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='nvp_value_elem' type-id='3ff5601b' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='96'>
	- <var-decl name='nvp_type' type-id='8d0687d2' visibility='default'/>
	- </data-member>
	- </class-decl>
	- <typedef-decl name='int16_t' type-id='a2185560' id='23bd8cb5'/>
	- <typedef-decl name='data_type_t' type-id='3ded3519' id='8d0687d2'/>
	- <enum-decl name='__anonymous_enum__4' is-anonymous='yes' id='3ded3519'>
	- <underlying-type type-id='9cac1fee'/>
	- <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='uchar_t' type-id='002ac4a6' id='d8bf0010'/>
	- <typedef-decl name='ssize_t' type-id='41060289' id='79a0948f'/>
	+ <data-member access='public' layout-offset-in-bits='0'>
	+ <var-decl name='__prev' type-id='4d98cd5a' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='64'>
	+ <var-decl name='__next' type-id='4d98cd5a' visibility='default'/>
	+ </data-member>
	+ </class-decl>
	+ <typedef-decl name='__pthread_list_t' type-id='0e01899c' id='518fb49c'/>
	+ <typedef-decl name='__uint8_t' type-id='002ac4a6' id='c51d6389'/>
	+ <typedef-decl name='__int16_t' type-id='a2185560' id='03896e23'/>
	+ <typedef-decl name='__int32_t' type-id='95e97e5e' id='33f57a65'/>
	+ <typedef-decl name='__uint32_t' type-id='f0981eeb' id='62f1140c'/>
	+ <typedef-decl name='__uint64_t' type-id='7359adad' id='8910171f'/>
	<typedef-decl name='__ssize_t' type-id='bd54fe1a' id='41060289'/>
	+ <typedef-decl name='ssize_t' type-id='41060289' id='79a0948f'/>
	+ <typedef-decl name='size_t' type-id='7359adad' id='b59d7dce'/>
	<pointer-type-def type-id='0e01899c' size-in-bits='64' id='4d98cd5a'/>
	<pointer-type-def type-id='c19b74c3' size-in-bits='64' id='37e3bd22'/>
	<pointer-type-def type-id='a84c031d' size-in-bits='64' id='26a90f95'/>
	<qualified-type-def type-id='a84c031d' const='yes' id='9b45d938'/>
	<pointer-type-def type-id='9b45d938' size-in-bits='64' id='80f4b756'/>
	<qualified-type-def type-id='8b8fc893' const='yes' id='9623bc03'/>
	<pointer-type-def type-id='9623bc03' size-in-bits='64' id='8341348b'/>
	<qualified-type-def type-id='8e8d4be3' const='yes' id='693c3853'/>
	<pointer-type-def type-id='693c3853' size-in-bits='64' id='22cce67b'/>
	<pointer-type-def type-id='95e97e5e' size-in-bits='64' id='7292109c'/>
	<pointer-type-def type-id='8e8d4be3' size-in-bits='64' id='5ce45b60'/>
	<pointer-type-def type-id='5ce45b60' size-in-bits='64' id='857bb57e'/>
	<pointer-type-def type-id='57928edf' size-in-bits='64' id='3fa542f0'/>
	<pointer-type-def type-id='7a6844eb' size-in-bits='64' id='18c91f9e'/>
	<pointer-type-def type-id='b59d7dce' size-in-bits='64' id='78c01427'/>
	<pointer-type-def type-id='d8bf0010' size-in-bits='64' id='45b65157'/>
	<pointer-type-def type-id='9c313c2d' size-in-bits='64' id='5d6479ae'/>
	<pointer-type-def type-id='b96825af' size-in-bits='64' id='ae3e8ca6'/>
	<pointer-type-def type-id='48b5725f' size-in-bits='64' id='eaa32e2f'/>
	<pointer-type-def type-id='3522cd69' size-in-bits='64' id='b65f7fd1'/>
	+ <function-decl name='zfs_ioctl_fd' mangled-name='zfs_ioctl_fd' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_ioctl_fd'>
	+ <parameter type-id='95e97e5e'/>
	+ <parameter type-id='7359adad'/>
	+ <parameter type-id='b65f7fd1'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='nvlist_free' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='5ce45b60'/>
	+ <return type-id='48b5725f'/>
	+ </function-decl>
	+ <function-decl name='nvlist_unpack' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='26a90f95'/>
	+ <parameter type-id='b59d7dce'/>
	+ <parameter type-id='857bb57e'/>
	+ <parameter type-id='95e97e5e'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='nvlist_lookup_uint64' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='5ce45b60'/>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='5d6479ae'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='nvlist_lookup_nvlist' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='5ce45b60'/>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='857bb57e'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='nvlist_next_nvpair' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='5ce45b60'/>
	+ <parameter type-id='3fa542f0'/>
	+ <return type-id='3fa542f0'/>
	+ </function-decl>
	+ <function-decl name='nvpair_name' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='3fa542f0'/>
	+ <return type-id='26a90f95'/>
	+ </function-decl>
	+ <function-decl name='fnvlist_alloc' visibility='default' binding='global' size-in-bits='64'>
	+ <return type-id='5ce45b60'/>
	+ </function-decl>
	+ <function-decl name='fnvlist_free' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='5ce45b60'/>
	+ <return type-id='48b5725f'/>
	+ </function-decl>
	+ <function-decl name='fnvlist_pack' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='5ce45b60'/>
	+ <parameter type-id='78c01427'/>
	+ <return type-id='26a90f95'/>
	+ </function-decl>
	+ <function-decl name='fnvlist_pack_free' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='26a90f95'/>
	+ <parameter type-id='b59d7dce'/>
	+ <return type-id='48b5725f'/>
	+ </function-decl>
	+ <function-decl name='fnvlist_unpack' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='26a90f95'/>
	+ <parameter type-id='b59d7dce'/>
	+ <return type-id='5ce45b60'/>
	+ </function-decl>
	+ <function-decl name='fnvlist_dup' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='5ce45b60'/>
	+ <return type-id='5ce45b60'/>
	+ </function-decl>
	+ <function-decl name='fnvlist_add_boolean' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='5ce45b60'/>
	+ <parameter type-id='80f4b756'/>
	+ <return type-id='48b5725f'/>
	+ </function-decl>
	+ <function-decl name='fnvlist_add_boolean_value' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='5ce45b60'/>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='c19b74c3'/>
	+ <return type-id='48b5725f'/>
	+ </function-decl>
	+ <function-decl name='fnvlist_add_int32' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='5ce45b60'/>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='3ff5601b'/>
	+ <return type-id='48b5725f'/>
	+ </function-decl>
	+ <function-decl name='fnvlist_add_uint64' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='5ce45b60'/>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='9c313c2d'/>
	+ <return type-id='48b5725f'/>
	+ </function-decl>
	+ <function-decl name='fnvlist_add_string' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='5ce45b60'/>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='80f4b756'/>
	+ <return type-id='48b5725f'/>
	+ </function-decl>
	+ <function-decl name='fnvlist_add_nvlist' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='5ce45b60'/>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='5ce45b60'/>
	+ <return type-id='48b5725f'/>
	+ </function-decl>
	+ <function-decl name='fnvlist_add_byte_array' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='5ce45b60'/>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='45b65157'/>
	+ <parameter type-id='3502e3ff'/>
	+ <return type-id='48b5725f'/>
	+ </function-decl>
	+ <function-decl name='fnvlist_add_uint8_array' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='5ce45b60'/>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='ae3e8ca6'/>
	+ <parameter type-id='3502e3ff'/>
	+ <return type-id='48b5725f'/>
	+ </function-decl>
	+ <function-decl name='fnvlist_lookup_boolean_value' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='5ce45b60'/>
	+ <parameter type-id='80f4b756'/>
	+ <return type-id='c19b74c3'/>
	+ </function-decl>
	+ <function-decl name='fnvlist_lookup_uint64' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='5ce45b60'/>
	+ <parameter type-id='80f4b756'/>
	+ <return type-id='9c313c2d'/>
	+ </function-decl>
	+ <function-decl name='fnvlist_lookup_string' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='5ce45b60'/>
	+ <parameter type-id='80f4b756'/>
	+ <return type-id='26a90f95'/>
	+ </function-decl>
	+ <function-decl name='libspl_assertf' mangled-name='libspl_assertf' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libspl_assertf'>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='95e97e5e'/>
	+ <parameter type-id='80f4b756'/>
	+ <parameter is-variadic='yes'/>
	+ <return type-id='48b5725f'/>
	+ </function-decl>
	+ <function-decl name='strlcpy' mangled-name='strlcpy' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='strlcpy'>
	+ <parameter type-id='26a90f95'/>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='b59d7dce'/>
	+ <return type-id='b59d7dce'/>
	+ </function-decl>
	<function-decl name='libzfs_core_init' mangled-name='libzfs_core_init' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libzfs_core_init'>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='libzfs_core_fini' mangled-name='libzfs_core_fini' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libzfs_core_fini'>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='lzc_create' mangled-name='lzc_create' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='lzc_create'>
	<parameter type-id='80f4b756' name='fsname'/>
	<parameter type-id='bc9887f1' name='type'/>
	<parameter type-id='5ce45b60' name='props'/>
	<parameter type-id='ae3e8ca6' name='wkeydata'/>
	<parameter type-id='3502e3ff' name='wkeylen'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='lzc_clone' mangled-name='lzc_clone' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='lzc_clone'>
	<parameter type-id='80f4b756' name='fsname'/>
	<parameter type-id='80f4b756' name='origin'/>
	<parameter type-id='5ce45b60' name='props'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='lzc_promote' mangled-name='lzc_promote' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='lzc_promote'>
	<parameter type-id='80f4b756' name='fsname'/>
	<parameter type-id='26a90f95' name='snapnamebuf'/>
	<parameter type-id='95e97e5e' name='snapnamelen'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='lzc_rename' mangled-name='lzc_rename' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='lzc_rename'>
	<parameter type-id='80f4b756' name='source'/>
	<parameter type-id='80f4b756' name='target'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='lzc_destroy' mangled-name='lzc_destroy' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='lzc_destroy'>
	<parameter type-id='80f4b756' name='fsname'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='lzc_snapshot' mangled-name='lzc_snapshot' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='lzc_snapshot'>
	<parameter type-id='5ce45b60' name='snaps'/>
	<parameter type-id='5ce45b60' name='props'/>
	<parameter type-id='857bb57e' name='errlist'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='lzc_destroy_snaps' mangled-name='lzc_destroy_snaps' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='lzc_destroy_snaps'>
	<parameter type-id='5ce45b60' name='snaps'/>
	<parameter type-id='c19b74c3' name='defer'/>
	<parameter type-id='857bb57e' name='errlist'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='lzc_snaprange_space' mangled-name='lzc_snaprange_space' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='lzc_snaprange_space'>
	<parameter type-id='80f4b756' name='firstsnap'/>
	<parameter type-id='80f4b756' name='lastsnap'/>
	<parameter type-id='5d6479ae' name='usedp'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='lzc_exists' mangled-name='lzc_exists' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='lzc_exists'>
	<parameter type-id='80f4b756' name='dataset'/>
	<return type-id='c19b74c3'/>
	</function-decl>
	<function-decl name='lzc_sync' mangled-name='lzc_sync' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='lzc_sync'>
	<parameter type-id='80f4b756' name='pool_name'/>
	<parameter type-id='5ce45b60' name='innvl'/>
	<parameter type-id='857bb57e' name='outnvl'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='lzc_hold' mangled-name='lzc_hold' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='lzc_hold'>
	<parameter type-id='5ce45b60' name='holds'/>
	<parameter type-id='95e97e5e' name='cleanup_fd'/>
	<parameter type-id='857bb57e' name='errlist'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='lzc_release' mangled-name='lzc_release' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='lzc_release'>
	<parameter type-id='5ce45b60' name='holds'/>
	<parameter type-id='857bb57e' name='errlist'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='lzc_get_holds' mangled-name='lzc_get_holds' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='lzc_get_holds'>
	<parameter type-id='80f4b756' name='snapname'/>
	<parameter type-id='857bb57e' name='holdsp'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='lzc_send_resume_redacted' mangled-name='lzc_send_resume_redacted' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='lzc_send_resume_redacted'>
	+ <function-decl name='lzc_send' mangled-name='lzc_send' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='lzc_send'>
	<parameter type-id='80f4b756' name='snapname'/>
	<parameter type-id='80f4b756' name='from'/>
	<parameter type-id='95e97e5e' name='fd'/>
	<parameter type-id='bfbd3c8e' name='flags'/>
	- <parameter type-id='9c313c2d' name='resumeobj'/>
	- <parameter type-id='9c313c2d' name='resumeoff'/>
	- <parameter type-id='80f4b756' name='redactbook'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='lzc_send' mangled-name='lzc_send' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='lzc_send'>
	+ <function-decl name='lzc_send_redacted' mangled-name='lzc_send_redacted' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='lzc_send_redacted'>
	<parameter type-id='80f4b756' name='snapname'/>
	<parameter type-id='80f4b756' name='from'/>
	<parameter type-id='95e97e5e' name='fd'/>
	<parameter type-id='bfbd3c8e' name='flags'/>
	+ <parameter type-id='80f4b756' name='redactbook'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='lzc_send_redacted' mangled-name='lzc_send_redacted' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='lzc_send_redacted'>
	+ <function-decl name='lzc_send_resume' mangled-name='lzc_send_resume' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='lzc_send_resume'>
	<parameter type-id='80f4b756' name='snapname'/>
	<parameter type-id='80f4b756' name='from'/>
	<parameter type-id='95e97e5e' name='fd'/>
	<parameter type-id='bfbd3c8e' name='flags'/>
	- <parameter type-id='80f4b756' name='redactbook'/>
	+ <parameter type-id='9c313c2d' name='resumeobj'/>
	+ <parameter type-id='9c313c2d' name='resumeoff'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='lzc_send_resume' mangled-name='lzc_send_resume' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='lzc_send_resume'>
	+ <function-decl name='lzc_send_resume_redacted' mangled-name='lzc_send_resume_redacted' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='lzc_send_resume_redacted'>
	<parameter type-id='80f4b756' name='snapname'/>
	<parameter type-id='80f4b756' name='from'/>
	<parameter type-id='95e97e5e' name='fd'/>
	<parameter type-id='bfbd3c8e' name='flags'/>
	<parameter type-id='9c313c2d' name='resumeobj'/>
	<parameter type-id='9c313c2d' name='resumeoff'/>
	+ <parameter type-id='80f4b756' name='redactbook'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='lzc_send_space_resume_redacted' mangled-name='lzc_send_space_resume_redacted' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='lzc_send_space_resume_redacted'>
	<parameter type-id='80f4b756' name='snapname'/>
	<parameter type-id='80f4b756' name='from'/>
	<parameter type-id='bfbd3c8e' name='flags'/>
	<parameter type-id='9c313c2d' name='resumeobj'/>
	<parameter type-id='9c313c2d' name='resumeoff'/>
	<parameter type-id='9c313c2d' name='resume_bytes'/>
	<parameter type-id='80f4b756' name='redactbook'/>
	<parameter type-id='95e97e5e' name='fd'/>
	<parameter type-id='5d6479ae' name='spacep'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='lzc_send_space' mangled-name='lzc_send_space' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='lzc_send_space'>
	<parameter type-id='80f4b756' name='snapname'/>
	<parameter type-id='80f4b756' name='from'/>
	<parameter type-id='bfbd3c8e' name='flags'/>
	<parameter type-id='5d6479ae' name='spacep'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='lzc_receive' mangled-name='lzc_receive' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='lzc_receive'>
	<parameter type-id='80f4b756' name='snapname'/>
	<parameter type-id='5ce45b60' name='props'/>
	<parameter type-id='80f4b756' name='origin'/>
	<parameter type-id='c19b74c3' name='force'/>
	<parameter type-id='c19b74c3' name='raw'/>
	<parameter type-id='95e97e5e' name='fd'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='lzc_receive_resumable' mangled-name='lzc_receive_resumable' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='lzc_receive_resumable'>
	<parameter type-id='80f4b756' name='snapname'/>
	<parameter type-id='5ce45b60' name='props'/>
	<parameter type-id='80f4b756' name='origin'/>
	<parameter type-id='c19b74c3' name='force'/>
	<parameter type-id='c19b74c3' name='raw'/>
	<parameter type-id='95e97e5e' name='fd'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='lzc_receive_with_header' mangled-name='lzc_receive_with_header' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='lzc_receive_with_header'>
	<parameter type-id='80f4b756' name='snapname'/>
	<parameter type-id='5ce45b60' name='props'/>
	<parameter type-id='80f4b756' name='origin'/>
	<parameter type-id='c19b74c3' name='force'/>
	<parameter type-id='c19b74c3' name='resumable'/>
	<parameter type-id='c19b74c3' name='raw'/>
	<parameter type-id='95e97e5e' name='fd'/>
	<parameter type-id='8341348b' name='begin_record'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='lzc_receive_one' mangled-name='lzc_receive_one' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='lzc_receive_one'>
	<parameter type-id='80f4b756' name='snapname'/>
	<parameter type-id='5ce45b60' name='props'/>
	<parameter type-id='80f4b756' name='origin'/>
	<parameter type-id='c19b74c3' name='force'/>
	<parameter type-id='c19b74c3' name='resumable'/>
	<parameter type-id='c19b74c3' name='raw'/>
	<parameter type-id='95e97e5e' name='input_fd'/>
	<parameter type-id='8341348b' name='begin_record'/>
	<parameter type-id='95e97e5e' name='cleanup_fd'/>
	<parameter type-id='5d6479ae' name='read_bytes'/>
	<parameter type-id='5d6479ae' name='errflags'/>
	<parameter type-id='5d6479ae' name='action_handle'/>
	<parameter type-id='857bb57e' name='errors'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='lzc_receive_with_cmdprops' mangled-name='lzc_receive_with_cmdprops' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='lzc_receive_with_cmdprops'>
	<parameter type-id='80f4b756' name='snapname'/>
	<parameter type-id='5ce45b60' name='props'/>
	<parameter type-id='5ce45b60' name='cmdprops'/>
	<parameter type-id='ae3e8ca6' name='wkeydata'/>
	<parameter type-id='3502e3ff' name='wkeylen'/>
	<parameter type-id='80f4b756' name='origin'/>
	<parameter type-id='c19b74c3' name='force'/>
	<parameter type-id='c19b74c3' name='resumable'/>
	<parameter type-id='c19b74c3' name='raw'/>
	<parameter type-id='95e97e5e' name='input_fd'/>
	<parameter type-id='8341348b' name='begin_record'/>
	<parameter type-id='95e97e5e' name='cleanup_fd'/>
	<parameter type-id='5d6479ae' name='read_bytes'/>
	<parameter type-id='5d6479ae' name='errflags'/>
	<parameter type-id='5d6479ae' name='action_handle'/>
	<parameter type-id='857bb57e' name='errors'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='lzc_rollback' mangled-name='lzc_rollback' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='lzc_rollback'>
	<parameter type-id='80f4b756' name='fsname'/>
	<parameter type-id='26a90f95' name='snapnamebuf'/>
	<parameter type-id='95e97e5e' name='snapnamelen'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='lzc_rollback_to' mangled-name='lzc_rollback_to' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='lzc_rollback_to'>
	<parameter type-id='80f4b756' name='fsname'/>
	<parameter type-id='80f4b756' name='snapname'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='lzc_bookmark' mangled-name='lzc_bookmark' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='lzc_bookmark'>
	<parameter type-id='5ce45b60' name='bookmarks'/>
	<parameter type-id='857bb57e' name='errlist'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='lzc_get_bookmarks' mangled-name='lzc_get_bookmarks' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='lzc_get_bookmarks'>
	<parameter type-id='80f4b756' name='fsname'/>
	<parameter type-id='5ce45b60' name='props'/>
	<parameter type-id='857bb57e' name='bmarks'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='lzc_get_bookmark_props' mangled-name='lzc_get_bookmark_props' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='lzc_get_bookmark_props'>
	<parameter type-id='80f4b756' name='bookmark'/>
	<parameter type-id='857bb57e' name='props'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='lzc_destroy_bookmarks' mangled-name='lzc_destroy_bookmarks' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='lzc_destroy_bookmarks'>
	<parameter type-id='5ce45b60' name='bmarks'/>
	<parameter type-id='857bb57e' name='errlist'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='lzc_channel_program' mangled-name='lzc_channel_program' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='lzc_channel_program'>
	<parameter type-id='80f4b756' name='pool'/>
	<parameter type-id='80f4b756' name='program'/>
	<parameter type-id='9c313c2d' name='instrlimit'/>
	<parameter type-id='9c313c2d' name='memlimit'/>
	<parameter type-id='5ce45b60' name='argnvl'/>
	<parameter type-id='857bb57e' name='outnvl'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='lzc_pool_checkpoint' mangled-name='lzc_pool_checkpoint' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='lzc_pool_checkpoint'>
	<parameter type-id='80f4b756' name='pool'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='lzc_pool_checkpoint_discard' mangled-name='lzc_pool_checkpoint_discard' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='lzc_pool_checkpoint_discard'>
	<parameter type-id='80f4b756' name='pool'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='lzc_channel_program_nosync' mangled-name='lzc_channel_program_nosync' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='lzc_channel_program_nosync'>
	<parameter type-id='80f4b756' name='pool'/>
	<parameter type-id='80f4b756' name='program'/>
	<parameter type-id='9c313c2d' name='timeout'/>
	<parameter type-id='9c313c2d' name='memlimit'/>
	<parameter type-id='5ce45b60' name='argnvl'/>
	<parameter type-id='857bb57e' name='outnvl'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='lzc_load_key' mangled-name='lzc_load_key' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='lzc_load_key'>
	<parameter type-id='80f4b756' name='fsname'/>
	<parameter type-id='c19b74c3' name='noop'/>
	<parameter type-id='ae3e8ca6' name='wkeydata'/>
	<parameter type-id='3502e3ff' name='wkeylen'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='lzc_unload_key' mangled-name='lzc_unload_key' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='lzc_unload_key'>
	<parameter type-id='80f4b756' name='fsname'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='lzc_change_key' mangled-name='lzc_change_key' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='lzc_change_key'>
	<parameter type-id='80f4b756' name='fsname'/>
	<parameter type-id='9c313c2d' name='crypt_cmd'/>
	<parameter type-id='5ce45b60' name='props'/>
	<parameter type-id='ae3e8ca6' name='wkeydata'/>
	<parameter type-id='3502e3ff' name='wkeylen'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='lzc_reopen' mangled-name='lzc_reopen' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='lzc_reopen'>
	<parameter type-id='80f4b756' name='pool_name'/>
	<parameter type-id='c19b74c3' name='scrub_restart'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='lzc_initialize' mangled-name='lzc_initialize' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='lzc_initialize'>
	<parameter type-id='80f4b756' name='poolname'/>
	<parameter type-id='7063e1ab' name='cmd_type'/>
	<parameter type-id='5ce45b60' name='vdevs'/>
	<parameter type-id='857bb57e' name='errlist'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='lzc_trim' mangled-name='lzc_trim' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='lzc_trim'>
	<parameter type-id='80f4b756' name='poolname'/>
	<parameter type-id='b1146b8d' name='cmd_type'/>
	<parameter type-id='9c313c2d' name='rate'/>
	<parameter type-id='c19b74c3' name='secure'/>
	<parameter type-id='5ce45b60' name='vdevs'/>
	<parameter type-id='857bb57e' name='errlist'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='lzc_redact' mangled-name='lzc_redact' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='lzc_redact'>
	<parameter type-id='80f4b756' name='snapshot'/>
	<parameter type-id='80f4b756' name='bookname'/>
	<parameter type-id='5ce45b60' name='snapnv'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='lzc_wait' mangled-name='lzc_wait' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='lzc_wait'>
	<parameter type-id='80f4b756' name='pool'/>
	<parameter type-id='73446457' name='activity'/>
	<parameter type-id='37e3bd22' name='waited'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='lzc_wait_tag' mangled-name='lzc_wait_tag' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='lzc_wait_tag'>
	<parameter type-id='80f4b756' name='pool'/>
	<parameter type-id='73446457' name='activity'/>
	<parameter type-id='9c313c2d' name='tag'/>
	<parameter type-id='37e3bd22' name='waited'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='lzc_wait_fs' mangled-name='lzc_wait_fs' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='lzc_wait_fs'>
	<parameter type-id='80f4b756' name='fs'/>
	<parameter type-id='3024501a' name='activity'/>
	<parameter type-id='37e3bd22' name='waited'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='lzc_set_bootenv' mangled-name='lzc_set_bootenv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='lzc_set_bootenv'>
	<parameter type-id='80f4b756' name='pool'/>
	<parameter type-id='22cce67b' name='env'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='lzc_get_bootenv' mangled-name='lzc_get_bootenv' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='lzc_get_bootenv'>
	<parameter type-id='80f4b756' name='pool'/>
	<parameter type-id='857bb57e' name='outnvl'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='libspl_assertf' mangled-name='libspl_assertf' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libspl_assertf'>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='95e97e5e'/>
	- <parameter type-id='80f4b756'/>
	- <parameter is-variadic='yes'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	- <function-decl name='strlcpy' mangled-name='strlcpy' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='strlcpy'>
	- <parameter type-id='26a90f95'/>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='b59d7dce'/>
	- <return type-id='b59d7dce'/>
	- </function-decl>
	- <function-decl name='fnvlist_pack' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='5ce45b60'/>
	- <parameter type-id='78c01427'/>
	- <return type-id='26a90f95'/>
	- </function-decl>
	- <function-decl name='malloc' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='b59d7dce'/>
	- <return type-id='eaa32e2f'/>
	- </function-decl>
	- <function-decl name='fnvlist_pack_free' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='26a90f95'/>
	- <parameter type-id='b59d7dce'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	- <function-decl name='free' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='eaa32e2f'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	- <function-decl name='__errno_location' visibility='default' binding='global' size-in-bits='64'>
	- <return type-id='7292109c'/>
	- </function-decl>
	- <function-decl name='zfs_ioctl_fd' mangled-name='zfs_ioctl_fd' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_ioctl_fd'>
	- <parameter type-id='95e97e5e'/>
	- <parameter type-id='7359adad'/>
	- <parameter type-id='b65f7fd1'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='fnvlist_unpack' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='26a90f95'/>
	- <parameter type-id='b59d7dce'/>
	- <return type-id='5ce45b60'/>
	- </function-decl>
	- <function-decl name='fnvlist_lookup_uint64' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='5ce45b60'/>
	- <parameter type-id='80f4b756'/>
	- <return type-id='9c313c2d'/>
	- </function-decl>
	- <function-decl name='fnvlist_alloc' visibility='default' binding='global' size-in-bits='64'>
	- <return type-id='5ce45b60'/>
	- </function-decl>
	- <function-decl name='fnvlist_add_string' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='5ce45b60'/>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='80f4b756'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	- <function-decl name='fnvlist_add_nvlist' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='5ce45b60'/>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='5ce45b60'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	- <function-decl name='fnvlist_add_boolean_value' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='5ce45b60'/>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='c19b74c3'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	- <function-decl name='fnvlist_add_uint64' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='5ce45b60'/>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='9c313c2d'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	- <function-decl name='fnvlist_free' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='5ce45b60'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	- <function-decl name='fnvlist_add_int32' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='5ce45b60'/>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='3ff5601b'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	- <function-decl name='fnvlist_lookup_boolean_value' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='5ce45b60'/>
	- <parameter type-id='80f4b756'/>
	- <return type-id='c19b74c3'/>
	+ <function-decl name='__errno_location' visibility='default' binding='global' size-in-bits='64'>
	+ <return type-id='7292109c'/>
	</function-decl>
	<function-decl name='pthread_mutex_lock' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='18c91f9e'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='pthread_mutex_unlock' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='18c91f9e'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='close' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='95e97e5e'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='fnvlist_add_uint8_array' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='5ce45b60'/>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='ae3e8ca6'/>
	- <parameter type-id='3502e3ff'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	- <function-decl name='nvlist_free' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='5ce45b60'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	- <function-decl name='nvlist_next_nvpair' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='5ce45b60'/>
	- <parameter type-id='3fa542f0'/>
	- <return type-id='3fa542f0'/>
	- </function-decl>
	- <function-decl name='nvpair_name' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='3fa542f0'/>
	- <return type-id='26a90f95'/>
	- </function-decl>
	- <function-decl name='fnvlist_add_boolean' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='5ce45b60'/>
	- <parameter type-id='80f4b756'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	- <function-decl name='nvlist_lookup_nvlist' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='5ce45b60'/>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='857bb57e'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='fnvlist_dup' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='5ce45b60'/>
	- <return type-id='5ce45b60'/>
	+ <function-decl name='malloc' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='b59d7dce'/>
	+ <return type-id='eaa32e2f'/>
	</function-decl>
	- <function-decl name='fnvlist_add_byte_array' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='5ce45b60'/>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='45b65157'/>
	- <parameter type-id='3502e3ff'/>
	+ <function-decl name='free' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='eaa32e2f'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='nvlist_lookup_uint64' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='5ce45b60'/>
	+ <function-decl name='strchr' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='80f4b756'/>
	- <parameter type-id='5d6479ae'/>
	- <return type-id='95e97e5e'/>
	+ <parameter type-id='95e97e5e'/>
	+ <return type-id='26a90f95'/>
	</function-decl>
	<function-decl name='strrchr' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='80f4b756'/>
	<parameter type-id='95e97e5e'/>
	<return type-id='26a90f95'/>
	</function-decl>
	- <function-decl name='nvlist_unpack' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='26a90f95'/>
	- <parameter type-id='b59d7dce'/>
	- <parameter type-id='857bb57e'/>
	+ <function-decl name='strcspn' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='80f4b756'/>
	+ <return type-id='b59d7dce'/>
	+ </function-decl>
	+ <function-decl name='close' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='95e97e5e'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='read' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='95e97e5e'/>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='b59d7dce'/>
	<return type-id='79a0948f'/>
	</function-decl>
	- <function-decl name='fnvlist_lookup_string' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='5ce45b60'/>
	- <parameter type-id='80f4b756'/>
	- <return type-id='26a90f95'/>
	- </function-decl>
	</abi-instr>
	- <abi-instr version='1.0' address-size='64' path='os/linux/zutil_device_path_os.c' language='LANG_C89'>
	+ <abi-instr address-size='64' path='os/linux/zutil_device_path_os.c' language='LANG_C99'>
	<array-type-def dimensions='1' type-id='a84c031d' size-in-bits='288' id='16e6f2c6'>
	- <subrange length='36' type-id='4c87fef4' id='ae666bde'/>
	+ <subrange length='36' type-id='7359adad' id='ae666bde'/>
	</array-type-def>
	<class-decl name='udev' is-struct='yes' visibility='default' is-declaration-only='yes' id='e4a7fb7f'/>
	<class-decl name='udev_device' is-struct='yes' visibility='default' is-declaration-only='yes' id='640b33ca'/>
	<array-type-def dimensions='1' type-id='a65ae39c' size-in-bits='960' id='fa198beb'>
	- <subrange length='1' type-id='4c87fef4' id='52f813b4'/>
	+ <subrange length='1' type-id='7359adad' id='52f813b4'/>
	</array-type-def>
	<type-decl name='long long int' size-in-bits='64' id='1eb56b1e'/>
	<array-type-def dimensions='1' type-id='3502e3ff' size-in-bits='384' id='dba89ba3'>
	- <subrange length='12' type-id='4c87fef4' id='84827bdc'/>
	+ <subrange length='12' type-id='7359adad' id='84827bdc'/>
	</array-type-def>
	<array-type-def dimensions='1' type-id='3502e3ff' size-in-bits='256' id='01d84ed4'>
	- <subrange length='8' type-id='4c87fef4' id='56e0c0b1'/>
	+ <subrange length='8' type-id='7359adad' id='56e0c0b1'/>
	</array-type-def>
	- <class-decl name='dirent' size-in-bits='2240' is-struct='yes' visibility='default' id='611586a1'>
	+ <class-decl name='dk_part' size-in-bits='960' is-struct='yes' visibility='default' id='a65ae39c'>
	<data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='d_ino' type-id='71288a47' visibility='default'/>
	+ <var-decl name='p_start' type-id='804dc465' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='d_off' type-id='724e4de6' visibility='default'/>
	+ <var-decl name='p_size' type-id='804dc465' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='d_reclen' type-id='8efea9e5' visibility='default'/>
	+ <var-decl name='p_guid' type-id='214f32ea' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='144'>
	- <var-decl name='d_type' type-id='002ac4a6' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='256'>
	+ <var-decl name='p_tag' type-id='d908a348' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='152'>
	- <var-decl name='d_name' type-id='d1617432' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='272'>
	+ <var-decl name='p_flag' type-id='d908a348' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='288'>
	+ <var-decl name='p_name' type-id='16e6f2c6' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='576'>
	+ <var-decl name='p_uguid' type-id='214f32ea' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='704'>
	+ <var-decl name='p_resv' type-id='01d84ed4' visibility='default'/>
	</data-member>
	</class-decl>
	<class-decl name='dk_gpt' size-in-bits='1920' is-struct='yes' visibility='default' id='dd4a2e5a'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='efi_version' type-id='3502e3ff' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='32'>
	<var-decl name='efi_nparts' type-id='3502e3ff' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='efi_part_size' type-id='3502e3ff' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='96'>
	<var-decl name='efi_lbasize' type-id='3502e3ff' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='efi_last_lba' type-id='804dc465' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	<var-decl name='efi_first_u_lba' type-id='804dc465' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='256'>
	<var-decl name='efi_last_u_lba' type-id='804dc465' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='320'>
	<var-decl name='efi_disk_uguid' type-id='214f32ea' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='448'>
	<var-decl name='efi_flags' type-id='3502e3ff' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='480'>
	<var-decl name='efi_reserved1' type-id='3502e3ff' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='512'>
	<var-decl name='efi_altern_lba' type-id='804dc465' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='576'>
	<var-decl name='efi_reserved' type-id='dba89ba3' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='960'>
	<var-decl name='efi_parts' type-id='fa198beb' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='diskaddr_t' type-id='9b3ff54f' id='804dc465'/>
	- <typedef-decl name='longlong_t' type-id='1eb56b1e' id='9b3ff54f'/>
	<class-decl name='uuid' size-in-bits='128' is-struct='yes' visibility='default' id='214f32ea'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='time_low' type-id='8f92235e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='32'>
	<var-decl name='time_mid' type-id='149c6638' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='48'>
	<var-decl name='time_hi_and_version' type-id='149c6638' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='clock_seq_hi_and_reserved' type-id='b96825af' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='72'>
	<var-decl name='clock_seq_low' type-id='b96825af' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='80'>
	<var-decl name='node_addr' type-id='0f562bd0' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='uint16_t' type-id='8efea9e5' id='149c6638'/>
	- <class-decl name='dk_part' size-in-bits='960' is-struct='yes' visibility='default' id='a65ae39c'>
	+ <typedef-decl name='ushort_t' type-id='8efea9e5' id='d908a348'/>
	+ <typedef-decl name='longlong_t' type-id='1eb56b1e' id='9b3ff54f'/>
	+ <typedef-decl name='diskaddr_t' type-id='9b3ff54f' id='804dc465'/>
	+ <class-decl name='dirent' size-in-bits='2240' is-struct='yes' visibility='default' id='611586a1'>
	<data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='p_start' type-id='804dc465' visibility='default'/>
	+ <var-decl name='d_ino' type-id='71288a47' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='p_size' type-id='804dc465' visibility='default'/>
	+ <var-decl name='d_off' type-id='724e4de6' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='p_guid' type-id='214f32ea' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='256'>
	- <var-decl name='p_tag' type-id='d908a348' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='272'>
	- <var-decl name='p_flag' type-id='d908a348' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='288'>
	- <var-decl name='p_name' type-id='16e6f2c6' visibility='default'/>
	+ <var-decl name='d_reclen' type-id='8efea9e5' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='576'>
	- <var-decl name='p_uguid' type-id='214f32ea' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='144'>
	+ <var-decl name='d_type' type-id='002ac4a6' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='704'>
	- <var-decl name='p_resv' type-id='01d84ed4' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='152'>
	+ <var-decl name='d_name' type-id='d1617432' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='ushort_t' type-id='8efea9e5' id='d908a348'/>
	+ <typedef-decl name='uint16_t' type-id='253c2d2a' id='149c6638'/>
	+ <typedef-decl name='__uint16_t' type-id='8efea9e5' id='253c2d2a'/>
	<pointer-type-def type-id='611586a1' size-in-bits='64' id='2e243169'/>
	<pointer-type-def type-id='dd4a2e5a' size-in-bits='64' id='0d8119a8'/>
	<pointer-type-def type-id='0d8119a8' size-in-bits='64' id='c43b27a6'/>
	<pointer-type-def type-id='e4a7fb7f' size-in-bits='64' id='025eefe7'/>
	<pointer-type-def type-id='640b33ca' size-in-bits='64' id='b32bae08'/>
	+ <class-decl name='udev' is-struct='yes' visibility='default' is-declaration-only='yes' id='e4a7fb7f'/>
	+ <class-decl name='udev_device' is-struct='yes' visibility='default' is-declaration-only='yes' id='640b33ca'/>
	+ <function-decl name='efi_alloc_and_init' mangled-name='efi_alloc_and_init' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='efi_alloc_and_init'>
	+ <parameter type-id='95e97e5e'/>
	+ <parameter type-id='8f92235e'/>
	+ <parameter type-id='c43b27a6'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='efi_free' mangled-name='efi_free' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='efi_free'>
	+ <parameter type-id='0d8119a8'/>
	+ <return type-id='48b5725f'/>
	+ </function-decl>
	+ <function-decl name='udev_new' visibility='default' binding='global' size-in-bits='64'>
	+ <return type-id='025eefe7'/>
	+ </function-decl>
	+ <function-decl name='udev_device_unref' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='b32bae08'/>
	+ <return type-id='b32bae08'/>
	+ </function-decl>
	+ <function-decl name='udev_device_new_from_subsystem_sysname' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='025eefe7'/>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='80f4b756'/>
	+ <return type-id='b32bae08'/>
	+ </function-decl>
	+ <function-decl name='udev_device_get_property_value' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='b32bae08'/>
	+ <parameter type-id='80f4b756'/>
	+ <return type-id='80f4b756'/>
	+ </function-decl>
	+ <function-decl name='fclose' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='822cd80b'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='fgets' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='266fe297'/>
	+ <parameter type-id='95e97e5e'/>
	+ <parameter type-id='e75a27e9'/>
	+ <return type-id='26a90f95'/>
	+ </function-decl>
	+ <function-decl name='strstr' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='80f4b756'/>
	+ <return type-id='26a90f95'/>
	+ </function-decl>
	+ <function-decl name='readlink' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='9d26089a'/>
	+ <parameter type-id='266fe297'/>
	+ <parameter type-id='b59d7dce'/>
	+ <return type-id='79a0948f'/>
	+ </function-decl>
	<function-decl name='zfs_strip_partition' mangled-name='zfs_strip_partition' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_strip_partition'>
	<parameter type-id='26a90f95' name='path'/>
	<return type-id='26a90f95'/>
	</function-decl>
	<function-decl name='zfs_strip_path' mangled-name='zfs_strip_path' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_strip_path'>
	<parameter type-id='26a90f95' name='path'/>
	<return type-id='26a90f95'/>
	</function-decl>
	<function-decl name='zfs_get_enclosure_sysfs_path' mangled-name='zfs_get_enclosure_sysfs_path' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_get_enclosure_sysfs_path'>
	<parameter type-id='80f4b756' name='dev_name'/>
	<return type-id='26a90f95'/>
	</function-decl>
	<function-decl name='zfs_dev_is_dm' mangled-name='zfs_dev_is_dm' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_dev_is_dm'>
	<parameter type-id='80f4b756' name='dev_name'/>
	<return type-id='c19b74c3'/>
	</function-decl>
	<function-decl name='zfs_dev_is_whole_disk' mangled-name='zfs_dev_is_whole_disk' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_dev_is_whole_disk'>
	<parameter type-id='80f4b756' name='dev_name'/>
	<return type-id='c19b74c3'/>
	</function-decl>
	<function-decl name='zfs_get_underlying_path' mangled-name='zfs_get_underlying_path' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_get_underlying_path'>
	<parameter type-id='80f4b756' name='dev_name'/>
	<return type-id='26a90f95'/>
	</function-decl>
	<function-decl name='is_mpath_whole_disk' mangled-name='is_mpath_whole_disk' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='is_mpath_whole_disk'>
	<parameter type-id='80f4b756' name='path'/>
	<return type-id='c19b74c3'/>
	</function-decl>
	- <function-decl name='strstr' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='80f4b756'/>
	- <return type-id='26a90f95'/>
	- </function-decl>
	- <function-decl name='readlink' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='26a90f95'/>
	- <parameter type-id='b59d7dce'/>
	- <return type-id='79a0948f'/>
	- </function-decl>
	- <function-decl name='efi_alloc_and_init' mangled-name='efi_alloc_and_init' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='efi_alloc_and_init'>
	- <parameter type-id='95e97e5e'/>
	- <parameter type-id='8f92235e'/>
	- <parameter type-id='c43b27a6'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='efi_free' mangled-name='efi_free' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='efi_free'>
	- <parameter type-id='0d8119a8'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	- <function-decl name='udev_device_get_property_value' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='b32bae08'/>
	- <parameter type-id='80f4b756'/>
	- <return type-id='80f4b756'/>
	- </function-decl>
	- <function-decl name='udev_new' visibility='default' binding='global' size-in-bits='64'>
	- <return type-id='025eefe7'/>
	- </function-decl>
	- <function-decl name='udev_device_new_from_subsystem_sysname' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='025eefe7'/>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='80f4b756'/>
	- <return type-id='b32bae08'/>
	- </function-decl>
	- <function-decl name='udev_device_unref' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='b32bae08'/>
	- <return type-id='b32bae08'/>
	- </function-decl>
	+ <type-decl name='unsigned short int' size-in-bits='16' id='8efea9e5'/>
	</abi-instr>
	- <abi-instr version='1.0' address-size='64' path='os/linux/zutil_import_os.c' language='LANG_C89'>
	+ <abi-instr address-size='64' path='os/linux/zutil_import_os.c' language='LANG_C99'>
	<class-decl name='blkid_struct_cache' is-struct='yes' visibility='default' is-declaration-only='yes' id='09286066'/>
	<class-decl name='blkid_struct_dev' is-struct='yes' visibility='default' is-declaration-only='yes' id='86223623'/>
	<class-decl name='blkid_struct_dev_iterate' is-struct='yes' visibility='default' is-declaration-only='yes' id='d88420d6'/>
	<class-decl name='udev_list_entry' is-struct='yes' visibility='default' is-declaration-only='yes' id='e7dbdca3'/>
	+ <typedef-decl name='__useconds_t' type-id='f0981eeb' id='4e80d4b1'/>
	+ <typedef-decl name='__clockid_t' type-id='95e97e5e' id='08f9a87a'/>
	+ <typedef-decl name='clockid_t' type-id='08f9a87a' id='a1c3b834'/>
	+ <typedef-decl name='blkid_dev' type-id='8433f053' id='f47b023a'/>
	<typedef-decl name='blkid_cache' type-id='940e3afc' id='0882dfdf'/>
	<typedef-decl name='blkid_dev_iterate' type-id='b8fa2efc' id='f4760fa7'/>
	- <typedef-decl name='blkid_dev' type-id='8433f053' id='f47b023a'/>
	- <typedef-decl name='clockid_t' type-id='08f9a87a' id='a1c3b834'/>
	- <typedef-decl name='__clockid_t' type-id='95e97e5e' id='08f9a87a'/>
	- <typedef-decl name='__useconds_t' type-id='f0981eeb' id='4e80d4b1'/>
	<pointer-type-def type-id='0882dfdf' size-in-bits='64' id='2e3e7caa'/>
	<pointer-type-def type-id='f47b023a' size-in-bits='64' id='d87f9b75'/>
	<pointer-type-def type-id='09286066' size-in-bits='64' id='940e3afc'/>
	<pointer-type-def type-id='86223623' size-in-bits='64' id='8433f053'/>
	<pointer-type-def type-id='d88420d6' size-in-bits='64' id='b8fa2efc'/>
	+ <qualified-type-def type-id='62f7a03d' restrict='yes' id='f1cadedf'/>
	<pointer-type-def type-id='a9c79a1f' size-in-bits='64' id='3d83ba87'/>
	<pointer-type-def type-id='e7dbdca3' size-in-bits='64' id='deabd0d3'/>
	- <function-decl name='zfs_dev_flush' mangled-name='zfs_dev_flush' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_dev_flush'>
	- <parameter type-id='95e97e5e' name='fd'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='zfs_device_get_devid' mangled-name='zfs_device_get_devid' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_device_get_devid'>
	- <parameter type-id='b32bae08' name='dev'/>
	- <parameter type-id='26a90f95' name='bufptr'/>
	- <parameter type-id='b59d7dce' name='buflen'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='zfs_device_get_physical' mangled-name='zfs_device_get_physical' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_device_get_physical'>
	- <parameter type-id='b32bae08' name='dev'/>
	- <parameter type-id='26a90f95' name='bufptr'/>
	- <parameter type-id='b59d7dce' name='buflen'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='zpool_label_disk_wait' mangled-name='zpool_label_disk_wait' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_label_disk_wait'>
	- <parameter type-id='80f4b756' name='path'/>
	- <parameter type-id='95e97e5e' name='timeout_ms'/>
	+ <class-decl name='blkid_struct_cache' is-struct='yes' visibility='default' is-declaration-only='yes' id='09286066'/>
	+ <class-decl name='blkid_struct_dev' is-struct='yes' visibility='default' is-declaration-only='yes' id='86223623'/>
	+ <class-decl name='blkid_struct_dev_iterate' is-struct='yes' visibility='default' is-declaration-only='yes' id='d88420d6'/>
	+ <class-decl name='udev_list_entry' is-struct='yes' visibility='default' is-declaration-only='yes' id='e7dbdca3'/>
	+ <function-decl name='nvlist_remove_all' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='5ce45b60'/>
	+ <parameter type-id='80f4b756'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zpool_open_func' mangled-name='zpool_open_func' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_open_func'>
	- <parameter type-id='eaa32e2f' name='arg'/>
	+ <function-decl name='blkid_put_cache' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='0882dfdf'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='blkid_get_cache' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='2e3e7caa'/>
	<parameter type-id='80f4b756'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='blkid_probe_all_new' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='0882dfdf'/>
	- <return type-id='95e97e5e'/>
	+ <function-decl name='blkid_dev_devname' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='f47b023a'/>
	+ <return type-id='80f4b756'/>
	</function-decl>
	<function-decl name='blkid_dev_iterate_begin' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='0882dfdf'/>
	<return type-id='f4760fa7'/>
	</function-decl>
	<function-decl name='blkid_dev_set_search' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='f4760fa7'/>
	- <parameter type-id='26a90f95'/>
	- <parameter type-id='26a90f95'/>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='80f4b756'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='blkid_dev_next' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='f4760fa7'/>
	<parameter type-id='d87f9b75'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='blkid_dev_devname' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='f47b023a'/>
	- <return type-id='80f4b756'/>
	- </function-decl>
	<function-decl name='blkid_dev_iterate_end' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='f4760fa7'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='blkid_put_cache' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='blkid_probe_all_new' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='0882dfdf'/>
	- <return type-id='48b5725f'/>
	+ <return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='udev_list_entry_get_name' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='deabd0d3'/>
	- <return type-id='80f4b756'/>
	+ <function-decl name='udev_unref' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='025eefe7'/>
	+ <return type-id='025eefe7'/>
	</function-decl>
	<function-decl name='udev_list_entry_get_next' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='deabd0d3'/>
	<return type-id='deabd0d3'/>
	</function-decl>
	- <function-decl name='udev_device_get_devlinks_list_entry' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='b32bae08'/>
	- <return type-id='deabd0d3'/>
	+ <function-decl name='udev_list_entry_get_name' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='deabd0d3'/>
	+ <return type-id='80f4b756'/>
	</function-decl>
	<function-decl name='udev_device_get_parent_with_subsystem_devtype' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='b32bae08'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='80f4b756'/>
	<return type-id='b32bae08'/>
	</function-decl>
	+ <function-decl name='udev_device_get_devlinks_list_entry' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='b32bae08'/>
	+ <return type-id='deabd0d3'/>
	+ </function-decl>
	+ <function-decl name='sched_yield' visibility='default' binding='global' size-in-bits='64'>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='strtoul' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='9d26089a'/>
	+ <parameter type-id='8c85230f'/>
	+ <parameter type-id='95e97e5e'/>
	+ <return type-id='7359adad'/>
	+ </function-decl>
	+ <function-decl name='strncasecmp' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='b59d7dce'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='stat64' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='9d26089a'/>
	+ <parameter type-id='f1cadedf'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	<function-decl name='clock_gettime' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='a1c3b834'/>
	<parameter type-id='3d83ba87'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='sched_yield' visibility='default' binding='global' size-in-bits='64'>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	<function-decl name='usleep' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='4e80d4b1'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='udev_unref' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='025eefe7'/>
	- <return type-id='025eefe7'/>
	- </function-decl>
	- <function-decl name='__xstat64' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='95e97e5e'/>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='62f7a03d'/>
	+ <function-decl name='zfs_dev_flush' mangled-name='zfs_dev_flush' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_dev_flush'>
	+ <parameter type-id='95e97e5e' name='fd'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='sscanf' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='80f4b756'/>
	- <parameter is-variadic='yes'/>
	+ <function-decl name='zfs_device_get_devid' mangled-name='zfs_device_get_devid' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_device_get_devid'>
	+ <parameter type-id='b32bae08' name='dev'/>
	+ <parameter type-id='26a90f95' name='bufptr'/>
	+ <parameter type-id='b59d7dce' name='buflen'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='strtoul' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='9b23c9ad'/>
	- <parameter type-id='95e97e5e'/>
	- <return type-id='7359adad'/>
	- </function-decl>
	- <function-decl name='strncasecmp' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='b59d7dce'/>
	+ <function-decl name='zfs_device_get_physical' mangled-name='zfs_device_get_physical' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_device_get_physical'>
	+ <parameter type-id='b32bae08' name='dev'/>
	+ <parameter type-id='26a90f95' name='bufptr'/>
	+ <parameter type-id='b59d7dce' name='buflen'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='nvlist_remove_all' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='5ce45b60'/>
	- <parameter type-id='80f4b756'/>
	+ <function-decl name='zpool_label_disk_wait' mangled-name='zpool_label_disk_wait' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_label_disk_wait'>
	+ <parameter type-id='80f4b756' name='path'/>
	+ <parameter type-id='95e97e5e' name='timeout_ms'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <pointer-type-def type-id='26a90f95' size-in-bits='64' id='9b23c9ad'/>
	</abi-instr>
	- <abi-instr version='1.0' address-size='64' path='zutil_device_path.c' language='LANG_C89'>
	+ <abi-instr address-size='64' path='zutil_device_path.c' language='LANG_C99'>
	+ <qualified-type-def type-id='26a90f95' restrict='yes' id='266fe297'/>
	<qualified-type-def type-id='80f4b756' const='yes' id='b99c00c9'/>
	<pointer-type-def type-id='b99c00c9' size-in-bits='64' id='13956559'/>
	+ <qualified-type-def type-id='80f4b756' restrict='yes' id='9d26089a'/>
	+ <function-decl name='zpool_default_search_paths' mangled-name='zpool_default_search_paths' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_default_search_paths'>
	+ <parameter type-id='78c01427'/>
	+ <return type-id='13956559'/>
	+ </function-decl>
	+ <function-decl name='zfs_append_partition' mangled-name='zfs_append_partition' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_append_partition'>
	+ <parameter type-id='26a90f95'/>
	+ <parameter type-id='b59d7dce'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='strlcat' mangled-name='strlcat' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='strlcat'>
	+ <parameter type-id='26a90f95'/>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='b59d7dce'/>
	+ <return type-id='b59d7dce'/>
	+ </function-decl>
	<function-decl name='zfs_resolve_shortname' mangled-name='zfs_resolve_shortname' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_resolve_shortname'>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='26a90f95' name='path'/>
	<parameter type-id='b59d7dce' name='len'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='zfs_strcmp_pathname' mangled-name='zfs_strcmp_pathname' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_strcmp_pathname'>
	<parameter type-id='80f4b756' name='name'/>
	<parameter type-id='80f4b756' name='cmp'/>
	<parameter type-id='95e97e5e' name='wholedisk'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zpool_default_search_paths' mangled-name='zpool_default_search_paths' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_default_search_paths'>
	- <parameter type-id='78c01427'/>
	- <return type-id='13956559'/>
	- </function-decl>
	<function-decl name='snprintf' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='26a90f95'/>
	<parameter type-id='b59d7dce'/>
	<parameter type-id='80f4b756'/>
	<parameter is-variadic='yes'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='access' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='getenv' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='80f4b756'/>
	+ <return type-id='26a90f95'/>
	+ </function-decl>
	+ <function-decl name='memset' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='eaa32e2f'/>
	<parameter type-id='95e97e5e'/>
	- <return type-id='95e97e5e'/>
	+ <parameter type-id='b59d7dce'/>
	+ <return type-id='eaa32e2f'/>
	</function-decl>
	- <function-decl name='getenv' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='strcmp' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='80f4b756'/>
	- <return type-id='26a90f95'/>
	+ <parameter type-id='80f4b756'/>
	+ <return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='__strdup' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='strdup' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='80f4b756'/>
	<return type-id='26a90f95'/>
	</function-decl>
	<function-decl name='strtok' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='26a90f95'/>
	- <parameter type-id='80f4b756'/>
	+ <parameter type-id='266fe297'/>
	+ <parameter type-id='9d26089a'/>
	<return type-id='26a90f95'/>
	</function-decl>
	<function-decl name='strlen' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='80f4b756'/>
	<return type-id='b59d7dce'/>
	</function-decl>
	- <function-decl name='zfs_append_partition' mangled-name='zfs_append_partition' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_append_partition'>
	- <parameter type-id='26a90f95'/>
	- <parameter type-id='b59d7dce'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='strlcat' mangled-name='strlcat' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='strlcat'>
	- <parameter type-id='26a90f95'/>
	+ <function-decl name='access' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='80f4b756'/>
	- <parameter type-id='b59d7dce'/>
	- <return type-id='b59d7dce'/>
	+ <parameter type-id='95e97e5e'/>
	+ <return type-id='95e97e5e'/>
	</function-decl>
	</abi-instr>
	- <abi-instr version='1.0' address-size='64' path='zutil_import.c' language='LANG_C89'>
	+ <abi-instr address-size='64' path='zutil_import.c' language='LANG_C99'>
	<array-type-def dimensions='1' type-id='03085adc' size-in-bits='192' id='083f8d58'>
	- <subrange length='3' type-id='4c87fef4' id='56f209d2'/>
	+ <subrange length='3' type-id='7359adad' id='56f209d2'/>
	</array-type-def>
	<array-type-def dimensions='1' type-id='bf311473' size-in-bits='128' id='f0f65199'>
	- <subrange length='2' type-id='4c87fef4' id='52efc4ef'/>
	+ <subrange length='2' type-id='7359adad' id='52efc4ef'/>
	</array-type-def>
	<array-type-def dimensions='1' type-id='a84c031d' size-in-bits='8192' id='b54ce520'>
	- <subrange length='1024' type-id='4c87fef4' id='c60446f8'/>
	+ <subrange length='1024' type-id='7359adad' id='c60446f8'/>
	</array-type-def>
	<array-type-def dimensions='1' type-id='a84c031d' size-in-bits='8' id='89feb1ec'>
	- <subrange length='1' type-id='4c87fef4' id='52f813b4'/>
	+ <subrange length='1' type-id='7359adad' id='52f813b4'/>
	</array-type-def>
	<array-type-def dimensions='1' type-id='a84c031d' size-in-bits='160' id='664ac0b7'>
	- <subrange length='20' type-id='4c87fef4' id='fdca39cf'/>
	+ <subrange length='20' type-id='7359adad' id='fdca39cf'/>
	</array-type-def>
	<array-type-def dimensions='1' type-id='a84c031d' size-in-bits='256' id='16dc656a'>
	- <subrange length='32' type-id='4c87fef4' id='ae5bde82'/>
	+ <subrange length='32' type-id='7359adad' id='ae5bde82'/>
	</array-type-def>
	<array-type-def dimensions='1' type-id='a84c031d' size-in-bits='32' id='8e0573fd'>
	- <subrange length='4' type-id='4c87fef4' id='16fe7105'/>
	+ <subrange length='4' type-id='7359adad' id='16fe7105'/>
	</array-type-def>
	<array-type-def dimensions='1' type-id='a84c031d' size-in-bits='448' id='6093ff7c'>
	- <subrange length='56' type-id='4c87fef4' id='f8137894'/>
	+ <subrange length='56' type-id='7359adad' id='f8137894'/>
	</array-type-def>
	+ <class-decl name='_IO_codecvt' is-struct='yes' visibility='default' is-declaration-only='yes' id='a4036571'/>
	+ <class-decl name='_IO_marker' is-struct='yes' visibility='default' is-declaration-only='yes' id='010ae0b9'/>
	+ <class-decl name='_IO_wide_data' is-struct='yes' visibility='default' is-declaration-only='yes' id='79bd3751'/>
	<class-decl name='__dirstream' is-struct='yes' visibility='default' is-declaration-only='yes' id='20cd73f2'/>
	<class-decl name='__va_list_tag' size-in-bits='192' is-struct='yes' visibility='default' id='d5027220'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='gp_offset' type-id='f0981eeb' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='32'>
	<var-decl name='fp_offset' type-id='f0981eeb' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='overflow_arg_area' type-id='eaa32e2f' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='reg_save_area' type-id='eaa32e2f' visibility='default'/>
	</data-member>
	</class-decl>
	<class-decl name='tpool' size-in-bits='2496' is-struct='yes' visibility='default' id='88d1b7f9'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='tp_forw' type-id='9cf59a50' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='tp_back' type-id='9cf59a50' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='tp_mutex' type-id='7a6844eb' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='448'>
	<var-decl name='tp_busycv' type-id='62fab762' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='832'>
	<var-decl name='tp_workcv' type-id='62fab762' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='1216'>
	<var-decl name='tp_waitcv' type-id='62fab762' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='1600'>
	<var-decl name='tp_active' type-id='ad33e5e7' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='1664'>
	<var-decl name='tp_head' type-id='f32b30e4' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='1728'>
	<var-decl name='tp_tail' type-id='f32b30e4' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='1792'>
	<var-decl name='tp_attr' type-id='7d8569fd' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='2240'>
	<var-decl name='tp_flags' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='2272'>
	<var-decl name='tp_linger' type-id='3502e3ff' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='2304'>
	<var-decl name='tp_njobs' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='2336'>
	- <var-decl name='tp_minimum' type-id='95e97e5e' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='2368'>
	- <var-decl name='tp_maximum' type-id='95e97e5e' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='2400'>
	- <var-decl name='tp_current' type-id='95e97e5e' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='2432'>
	- <var-decl name='tp_idle' type-id='95e97e5e' visibility='default'/>
	- </data-member>
	- </class-decl>
	- <array-type-def dimensions='1' type-id='95e97e5e' size-in-bits='384' id='73b82f0f'>
	- <subrange length='12' type-id='4c87fef4' id='84827bdc'/>
	- </array-type-def>
	- <type-decl name='long long unsigned int' size-in-bits='64' id='3a47d82b'/>
	- <type-decl name='signed char' size-in-bits='8' id='28577a57'/>
	- <type-decl name='unsigned short int' size-in-bits='16' id='8efea9e5'/>
	- <typedef-decl name='libpc_handle_t' type-id='7c8737f0' id='8a70a786'/>
	- <class-decl name='libpc_handle' size-in-bits='8448' is-struct='yes' visibility='default' id='7c8737f0'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='lpc_printerr' type-id='c19b74c3' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='32'>
	- <var-decl name='lpc_open_access_error' type-id='c19b74c3' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='lpc_desc_active' type-id='c19b74c3' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='96'>
	- <var-decl name='lpc_desc' type-id='b54ce520' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='8320'>
	- <var-decl name='lpc_ops' type-id='f095e320' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='8384'>
	- <var-decl name='lpc_lib_handle' type-id='eaa32e2f' visibility='default'/>
	- </data-member>
	- </class-decl>
	- <typedef-decl name='pool_config_ops_t' type-id='1a21babe' id='b1e62775'/>
	- <class-decl name='pool_config_ops' size-in-bits='128' is-struct='yes' visibility='default' id='8b092c69'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='pco_refresh_config' type-id='e7c00489' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='pco_pool_active' type-id='9eadf5e0' visibility='default'/>
	- </data-member>
	- </class-decl>
	- <typedef-decl name='refresh_config_func_t' type-id='29f040d2' id='b7c58eaa'/>
	- <typedef-decl name='pool_active_func_t' type-id='baa42fef' id='de5d1d8f'/>
	- <typedef-decl name='importargs_t' type-id='7ac83801' id='7a842a6b'/>
	- <class-decl name='importargs' size-in-bits='448' is-struct='yes' visibility='default' id='7ac83801'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='path' type-id='9b23c9ad' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='paths' type-id='95e97e5e' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='poolname' type-id='80f4b756' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='192'>
	- <var-decl name='guid' type-id='9c313c2d' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='256'>
	- <var-decl name='cachefile' type-id='80f4b756' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='320'>
	- <var-decl name='can_be_active' type-id='c19b74c3' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='352'>
	- <var-decl name='scan' type-id='c19b74c3' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='384'>
	- <var-decl name='policy' type-id='5ce45b60' visibility='default'/>
	- </data-member>
	- </class-decl>
	- <typedef-decl name='FILE' type-id='ec1ed955' id='aa12d1ba'/>
	- <class-decl name='_IO_FILE' size-in-bits='1728' is-struct='yes' visibility='default' id='ec1ed955'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='_flags' type-id='95e97e5e' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='_IO_read_ptr' type-id='26a90f95' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='_IO_read_end' type-id='26a90f95' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='192'>
	- <var-decl name='_IO_read_base' type-id='26a90f95' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='256'>
	- <var-decl name='_IO_write_base' type-id='26a90f95' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='320'>
	- <var-decl name='_IO_write_ptr' type-id='26a90f95' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='384'>
	- <var-decl name='_IO_write_end' type-id='26a90f95' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='448'>
	- <var-decl name='_IO_buf_base' type-id='26a90f95' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='512'>
	- <var-decl name='_IO_buf_end' type-id='26a90f95' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='576'>
	- <var-decl name='_IO_save_base' type-id='26a90f95' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='640'>
	- <var-decl name='_IO_backup_base' type-id='26a90f95' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='704'>
	- <var-decl name='_IO_save_end' type-id='26a90f95' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='768'>
	- <var-decl name='_markers' type-id='e4c6fa61' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='832'>
	- <var-decl name='_chain' type-id='dca988a5' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='896'>
	- <var-decl name='_fileno' type-id='95e97e5e' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='928'>
	- <var-decl name='_flags2' type-id='95e97e5e' visibility='default'/>
	+ <var-decl name='tp_minimum' type-id='95e97e5e' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='960'>
	- <var-decl name='_old_offset' type-id='79989e9c' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='2368'>
	+ <var-decl name='tp_maximum' type-id='95e97e5e' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='1024'>
	- <var-decl name='_cur_column' type-id='8efea9e5' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='2400'>
	+ <var-decl name='tp_current' type-id='95e97e5e' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='1040'>
	- <var-decl name='_vtable_offset' type-id='28577a57' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='2432'>
	+ <var-decl name='tp_idle' type-id='95e97e5e' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='1048'>
	- <var-decl name='_shortbuf' type-id='89feb1ec' visibility='default'/>
	+ </class-decl>
	+ <array-type-def dimensions='1' type-id='95e97e5e' size-in-bits='384' id='73b82f0f'>
	+ <subrange length='12' type-id='7359adad' id='84827bdc'/>
	+ </array-type-def>
	+ <type-decl name='long long unsigned int' size-in-bits='64' id='3a47d82b'/>
	+ <type-decl name='signed char' size-in-bits='8' id='28577a57'/>
	+ <type-decl name='unsigned short int' size-in-bits='16' id='8efea9e5'/>
	+ <typedef-decl name='refresh_config_func_t' type-id='29f040d2' id='b7c58eaa'/>
	+ <typedef-decl name='pool_active_func_t' type-id='baa42fef' id='de5d1d8f'/>
	+ <class-decl name='pool_config_ops' size-in-bits='128' is-struct='yes' visibility='default' id='8b092c69'>
	+ <data-member access='public' layout-offset-in-bits='0'>
	+ <var-decl name='pco_refresh_config' type-id='e7c00489' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='1088'>
	- <var-decl name='_lock' type-id='cecf4ea7' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='64'>
	+ <var-decl name='pco_pool_active' type-id='9eadf5e0' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='1152'>
	- <var-decl name='_offset' type-id='724e4de6' visibility='default'/>
	+ </class-decl>
	+ <typedef-decl name='pool_config_ops_t' type-id='1a21babe' id='b1e62775'/>
	+ <class-decl name='importargs' size-in-bits='448' is-struct='yes' visibility='default' id='7ac83801'>
	+ <data-member access='public' layout-offset-in-bits='0'>
	+ <var-decl name='path' type-id='9b23c9ad' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='1216'>
	- <var-decl name='__pad1' type-id='eaa32e2f' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='64'>
	+ <var-decl name='paths' type-id='95e97e5e' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='1280'>
	- <var-decl name='__pad2' type-id='eaa32e2f' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='128'>
	+ <var-decl name='poolname' type-id='80f4b756' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='1344'>
	- <var-decl name='__pad3' type-id='eaa32e2f' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='192'>
	+ <var-decl name='guid' type-id='9c313c2d' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='1408'>
	- <var-decl name='__pad4' type-id='eaa32e2f' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='256'>
	+ <var-decl name='cachefile' type-id='80f4b756' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='1472'>
	- <var-decl name='__pad5' type-id='b59d7dce' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='320'>
	+ <var-decl name='can_be_active' type-id='c19b74c3' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='1536'>
	- <var-decl name='_mode' type-id='95e97e5e' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='352'>
	+ <var-decl name='scan' type-id='c19b74c3' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='1568'>
	- <var-decl name='_unused2' type-id='664ac0b7' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='384'>
	+ <var-decl name='policy' type-id='5ce45b60' visibility='default'/>
	</data-member>
	</class-decl>
	- <class-decl name='_IO_marker' size-in-bits='192' is-struct='yes' visibility='default' id='010ae0b9'>
	+ <typedef-decl name='importargs_t' type-id='7ac83801' id='7a842a6b'/>
	+ <typedef-decl name='pool_vdev_iter_f' type-id='6c16a6c8' id='dff793e0'/>
	+ <typedef-decl name='avl_tree_t' type-id='b351119f' id='f20fbd51'/>
	+ <typedef-decl name='avl_index_t' type-id='e475ab95' id='fba6cb51'/>
	+ <class-decl name='avl_node' size-in-bits='192' is-struct='yes' visibility='default' id='428b67b3'>
	<data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='_next' type-id='e4c6fa61' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='_sbuf' type-id='dca988a5' visibility='default'/>
	+ <var-decl name='avl_child' type-id='f0f65199' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='_pos' type-id='95e97e5e' visibility='default'/>
	+ <var-decl name='avl_pcb' type-id='e475ab95' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='__off_t' type-id='bd54fe1a' id='79989e9c'/>
	- <typedef-decl name='_IO_lock_t' type-id='48b5725f' id='bb4788fa'/>
	- <typedef-decl name='__off64_t' type-id='bd54fe1a' id='724e4de6'/>
	- <typedef-decl name='avl_tree_t' type-id='b351119f' id='f20fbd51'/>
	<class-decl name='avl_tree' size-in-bits='320' is-struct='yes' visibility='default' id='b351119f'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='avl_root' type-id='bf311473' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='avl_compar' type-id='585e1de9' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='avl_offset' type-id='b59d7dce' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	<var-decl name='avl_numnodes' type-id='ee1f298e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='256'>
	<var-decl name='avl_size' type-id='b59d7dce' visibility='default'/>
	</data-member>
	</class-decl>
	- <class-decl name='avl_node' size-in-bits='192' is-struct='yes' visibility='default' id='428b67b3'>
	+ <typedef-decl name='tpool_t' type-id='88d1b7f9' id='b1bbf10d'/>
	+ <typedef-decl name='ulong_t' type-id='7359adad' id='ee1f298e'/>
	+ <class-decl name='libpc_handle' size-in-bits='8448' is-struct='yes' visibility='default' id='7c8737f0'>
	<data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='avl_child' type-id='f0f65199' visibility='default'/>
	+ <var-decl name='lpc_printerr' type-id='c19b74c3' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='32'>
	+ <var-decl name='lpc_open_access_error' type-id='c19b74c3' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='64'>
	+ <var-decl name='lpc_desc_active' type-id='c19b74c3' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='96'>
	+ <var-decl name='lpc_desc' type-id='b54ce520' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='8320'>
	+ <var-decl name='lpc_ops' type-id='f095e320' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='8384'>
	+ <var-decl name='lpc_lib_handle' type-id='eaa32e2f' visibility='default'/>
	+ </data-member>
	+ </class-decl>
	+ <typedef-decl name='libpc_handle_t' type-id='7c8737f0' id='8a70a786'/>
	+ <class-decl name='aiocb' size-in-bits='1344' is-struct='yes' visibility='default' id='e4957c49'>
	+ <data-member access='public' layout-offset-in-bits='0'>
	+ <var-decl name='aio_fildes' type-id='95e97e5e' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='32'>
	+ <var-decl name='aio_lio_opcode' type-id='95e97e5e' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='64'>
	+ <var-decl name='aio_reqprio' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='avl_pcb' type-id='e475ab95' visibility='default'/>
	+ <var-decl name='aio_buf' type-id='fe09dd29' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='192'>
	+ <var-decl name='aio_nbytes' type-id='b59d7dce' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='256'>
	+ <var-decl name='aio_sigevent' type-id='519bc206' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='768'>
	+ <var-decl name='__next_prio' type-id='924bbc81' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='832'>
	+ <var-decl name='__abs_prio' type-id='95e97e5e' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='864'>
	+ <var-decl name='__policy' type-id='95e97e5e' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='896'>
	+ <var-decl name='__error_code' type-id='95e97e5e' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='960'>
	+ <var-decl name='__return_value' type-id='41060289' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='1024'>
	+ <var-decl name='aio_offset' type-id='724e4de6' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='1088'>
	+ <var-decl name='__glibc_reserved' type-id='16dc656a' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='uintptr_t' type-id='7359adad' id='e475ab95'/>
	- <typedef-decl name='ulong_t' type-id='7359adad' id='ee1f298e'/>
	- <typedef-decl name='avl_index_t' type-id='e475ab95' id='fba6cb51'/>
	- <typedef-decl name='DIR' type-id='20cd73f2' id='54a5d683'/>
	<class-decl name='dirent64' size-in-bits='2240' is-struct='yes' visibility='default' id='5725d813'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='d_ino' type-id='71288a47' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='d_off' type-id='724e4de6' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='d_reclen' type-id='8efea9e5' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='144'>
	<var-decl name='d_type' type-id='002ac4a6' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='152'>
	<var-decl name='d_name' type-id='d1617432' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='__ino64_t' type-id='7359adad' id='71288a47'/>
	- <typedef-decl name='tpool_t' type-id='88d1b7f9' id='b1bbf10d'/>
	- <typedef-decl name='pthread_attr_t' type-id='b63afacd' id='7d8569fd'/>
	+ <union-decl name='pthread_mutexattr_t' size-in-bits='32' naming-typedef-id='8afd6070' visibility='default' id='7300eb00'>
	+ <data-member access='public'>
	+ <var-decl name='__size' type-id='8e0573fd' visibility='default'/>
	+ </data-member>
	+ <data-member access='public'>
	+ <var-decl name='__align' type-id='95e97e5e' visibility='default'/>
	+ </data-member>
	+ </union-decl>
	+ <typedef-decl name='pthread_mutexattr_t' type-id='7300eb00' id='8afd6070'/>
	<union-decl name='pthread_attr_t' size-in-bits='448' visibility='default' id='b63afacd'>
	- <data-member access='private'>
	+ <data-member access='public'>
	<var-decl name='__size' type-id='6093ff7c' visibility='default'/>
	</data-member>
	- <data-member access='private'>
	+ <data-member access='public'>
	<var-decl name='__align' type-id='bd54fe1a' visibility='default'/>
	</data-member>
	</union-decl>
	- <class-decl name='stat64' size-in-bits='1152' is-struct='yes' visibility='default' id='0bbec9cd'>
	+ <typedef-decl name='pthread_attr_t' type-id='b63afacd' id='7d8569fd'/>
	+ <class-decl name='stat' size-in-bits='1152' is-struct='yes' visibility='default' id='aafc373f'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='st_dev' type-id='35ed8932' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='st_ino' type-id='71288a47' visibility='default'/>
	+ <var-decl name='st_ino' type-id='e43e523d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='st_nlink' type-id='80f0b9df' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	<var-decl name='st_mode' type-id='e1c52942' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='224'>
	<var-decl name='st_uid' type-id='cc5fcceb' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='256'>
	<var-decl name='st_gid' type-id='d94ec6d9' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='288'>
	<var-decl name='__pad0' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='320'>
	<var-decl name='st_rdev' type-id='35ed8932' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='384'>
	<var-decl name='st_size' type-id='79989e9c' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='448'>
	<var-decl name='st_blksize' type-id='d3f10a7f' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='512'>
	- <var-decl name='st_blocks' type-id='4e711bf1' visibility='default'/>
	+ <var-decl name='st_blocks' type-id='dbc43803' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='576'>
	<var-decl name='st_atim' type-id='a9c79a1f' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='704'>
	<var-decl name='st_mtim' type-id='a9c79a1f' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='832'>
	<var-decl name='st_ctim' type-id='a9c79a1f' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='960'>
	- <var-decl name='__unused' type-id='083f8d58' visibility='default'/>
	- </data-member>
	- </class-decl>
	- <typedef-decl name='__dev_t' type-id='7359adad' id='35ed8932'/>
	- <typedef-decl name='__nlink_t' type-id='7359adad' id='80f0b9df'/>
	- <typedef-decl name='__mode_t' type-id='f0981eeb' id='e1c52942'/>
	- <typedef-decl name='__uid_t' type-id='f0981eeb' id='cc5fcceb'/>
	- <typedef-decl name='__gid_t' type-id='f0981eeb' id='d94ec6d9'/>
	- <typedef-decl name='__blksize_t' type-id='bd54fe1a' id='d3f10a7f'/>
	- <typedef-decl name='__blkcnt64_t' type-id='bd54fe1a' id='4e711bf1'/>
	- <class-decl name='timespec' size-in-bits='128' is-struct='yes' visibility='default' id='a9c79a1f'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='tv_sec' type-id='65eda9c0' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='tv_nsec' type-id='03085adc' visibility='default'/>
	+ <var-decl name='__glibc_reserved' type-id='083f8d58' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='__time_t' type-id='bd54fe1a' id='65eda9c0'/>
	- <typedef-decl name='__syscall_slong_t' type-id='bd54fe1a' id='03085adc'/>
	- <class-decl name='aiocb' size-in-bits='1344' is-struct='yes' visibility='default' id='e4957c49'>
	+ <class-decl name='stat64' size-in-bits='1152' is-struct='yes' visibility='default' id='0bbec9cd'>
	<data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='aio_fildes' type-id='95e97e5e' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='32'>
	- <var-decl name='aio_lio_opcode' type-id='95e97e5e' visibility='default'/>
	+ <var-decl name='st_dev' type-id='35ed8932' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='aio_reqprio' type-id='95e97e5e' visibility='default'/>
	+ <var-decl name='st_ino' type-id='71288a47' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='aio_buf' type-id='fe09dd29' visibility='default'/>
	+ <var-decl name='st_nlink' type-id='80f0b9df' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	- <var-decl name='aio_nbytes' type-id='b59d7dce' visibility='default'/>
	+ <var-decl name='st_mode' type-id='e1c52942' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='224'>
	+ <var-decl name='st_uid' type-id='cc5fcceb' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='256'>
	- <var-decl name='aio_sigevent' type-id='519bc206' visibility='default'/>
	+ <var-decl name='st_gid' type-id='d94ec6d9' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='768'>
	- <var-decl name='__next_prio' type-id='924bbc81' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='288'>
	+ <var-decl name='__pad0' type-id='95e97e5e' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='832'>
	- <var-decl name='__abs_prio' type-id='95e97e5e' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='320'>
	+ <var-decl name='st_rdev' type-id='35ed8932' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='864'>
	- <var-decl name='__policy' type-id='95e97e5e' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='384'>
	+ <var-decl name='st_size' type-id='79989e9c' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='896'>
	- <var-decl name='__error_code' type-id='95e97e5e' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='448'>
	+ <var-decl name='st_blksize' type-id='d3f10a7f' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='960'>
	- <var-decl name='__return_value' type-id='41060289' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='512'>
	+ <var-decl name='st_blocks' type-id='4e711bf1' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='1024'>
	- <var-decl name='aio_offset' type-id='724e4de6' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='576'>
	+ <var-decl name='st_atim' type-id='a9c79a1f' visibility='default'/>
	</data-member>
	- <data-member access='public' layout-offset-in-bits='1088'>
	- <var-decl name='__unused' type-id='16dc656a' visibility='default'/>
	+ <data-member access='public' layout-offset-in-bits='704'>
	+ <var-decl name='st_mtim' type-id='a9c79a1f' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='832'>
	+ <var-decl name='st_ctim' type-id='a9c79a1f' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='960'>
	+ <var-decl name='__glibc_reserved' type-id='083f8d58' visibility='default'/>
	</data-member>
	</class-decl>
	+ <typedef-decl name='__dev_t' type-id='7359adad' id='35ed8932'/>
	+ <typedef-decl name='__uid_t' type-id='f0981eeb' id='cc5fcceb'/>
	+ <typedef-decl name='__gid_t' type-id='f0981eeb' id='d94ec6d9'/>
	+ <typedef-decl name='__ino_t' type-id='7359adad' id='e43e523d'/>
	+ <typedef-decl name='__ino64_t' type-id='7359adad' id='71288a47'/>
	+ <typedef-decl name='__mode_t' type-id='f0981eeb' id='e1c52942'/>
	+ <typedef-decl name='__nlink_t' type-id='7359adad' id='80f0b9df'/>
	+ <typedef-decl name='__off_t' type-id='bd54fe1a' id='79989e9c'/>
	+ <typedef-decl name='__off64_t' type-id='bd54fe1a' id='724e4de6'/>
	+ <typedef-decl name='__pid_t' type-id='95e97e5e' id='3629bad8'/>
	+ <typedef-decl name='__time_t' type-id='bd54fe1a' id='65eda9c0'/>
	+ <typedef-decl name='__blksize_t' type-id='bd54fe1a' id='d3f10a7f'/>
	+ <typedef-decl name='__blkcnt_t' type-id='bd54fe1a' id='dbc43803'/>
	+ <typedef-decl name='__blkcnt64_t' type-id='bd54fe1a' id='4e711bf1'/>
	+ <typedef-decl name='__syscall_slong_t' type-id='bd54fe1a' id='03085adc'/>
	+ <typedef-decl name='FILE' type-id='ec1ed955' id='aa12d1ba'/>
	+ <union-decl name='sigval' size-in-bits='64' visibility='default' id='a094b870'>
	+ <data-member access='public'>
	+ <var-decl name='sival_int' type-id='95e97e5e' visibility='default'/>
	+ </data-member>
	+ <data-member access='public'>
	+ <var-decl name='sival_ptr' type-id='eaa32e2f' visibility='default'/>
	+ </data-member>
	+ </union-decl>
	+ <typedef-decl name='__sigval_t' type-id='a094b870' id='eabacd01'/>
	<class-decl name='sigevent' size-in-bits='512' is-struct='yes' visibility='default' id='519bc206'>
	<data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='sigev_value' type-id='95506cfb' visibility='default'/>
	+ <var-decl name='sigev_value' type-id='eabacd01' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='sigev_signo' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='96'>
	<var-decl name='sigev_notify' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='_sigev_un' type-id='6e31adc3' visibility='default'/>
	+ <var-decl name='_sigev_un' type-id='ac5ab598' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='sigval_t' type-id='a094b870' id='95506cfb'/>
	- <union-decl name='sigval' size-in-bits='64' visibility='default' id='a094b870'>
	- <data-member access='private'>
	- <var-decl name='sival_int' type-id='95e97e5e' visibility='default'/>
	- </data-member>
	- <data-member access='private'>
	- <var-decl name='sival_ptr' type-id='eaa32e2f' visibility='default'/>
	- </data-member>
	- </union-decl>
	- <union-decl name='__anonymous_union__' size-in-bits='384' is-anonymous='yes' visibility='default' id='6e31adc3'>
	- <data-member access='private'>
	+ <union-decl name='__anonymous_union__' size-in-bits='384' is-anonymous='yes' visibility='default' id='ac5ab598'>
	+ <data-member access='public'>
	<var-decl name='_pad' type-id='73b82f0f' visibility='default'/>
	</data-member>
	- <data-member access='private'>
	+ <data-member access='public'>
	<var-decl name='_tid' type-id='3629bad8' visibility='default'/>
	</data-member>
	- <data-member access='private'>
	- <var-decl name='_sigev_thread' type-id='61c28a6f' visibility='default'/>
	+ <data-member access='public'>
	+ <var-decl name='_sigev_thread' type-id='e7f43f73' visibility='default'/>
	</data-member>
	</union-decl>
	- <typedef-decl name='__pid_t' type-id='95e97e5e' id='3629bad8'/>
	- <class-decl name='__anonymous_struct__' size-in-bits='128' is-struct='yes' is-anonymous='yes' visibility='default' id='61c28a6f'>
	+ <class-decl name='__anonymous_struct__' size-in-bits='128' is-struct='yes' is-anonymous='yes' visibility='default' id='e7f43f73'>
	<data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='_function' type-id='b4a8d2f6' visibility='default'/>
	+ <var-decl name='_function' type-id='5f147c28' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='_attribute' type-id='7347a39e' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='pthread_mutexattr_t' type-id='e7fcd879' id='8afd6070'/>
	- <union-decl name='__anonymous_union__1' size-in-bits='32' is-anonymous='yes' visibility='default' id='e7fcd879'>
	- <data-member access='private'>
	- <var-decl name='__size' type-id='8e0573fd' visibility='default'/>
	- </data-member>
	- <data-member access='private'>
	- <var-decl name='__align' type-id='95e97e5e' visibility='default'/>
	- </data-member>
	- </union-decl>
	- <class-decl name='stat' size-in-bits='1152' is-struct='yes' visibility='default' id='aafc373f'>
	+ <typedef-decl name='_IO_lock_t' type-id='48b5725f' id='bb4788fa'/>
	+ <class-decl name='_IO_FILE' size-in-bits='1728' is-struct='yes' visibility='default' id='ec1ed955'>
	<data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='st_dev' type-id='35ed8932' visibility='default'/>
	+ <var-decl name='_flags' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='st_ino' type-id='e43e523d' visibility='default'/>
	+ <var-decl name='_IO_read_ptr' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='st_nlink' type-id='80f0b9df' visibility='default'/>
	+ <var-decl name='_IO_read_end' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	- <var-decl name='st_mode' type-id='e1c52942' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='224'>
	- <var-decl name='st_uid' type-id='cc5fcceb' visibility='default'/>
	+ <var-decl name='_IO_read_base' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='256'>
	- <var-decl name='st_gid' type-id='d94ec6d9' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='288'>
	- <var-decl name='__pad0' type-id='95e97e5e' visibility='default'/>
	+ <var-decl name='_IO_write_base' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='320'>
	- <var-decl name='st_rdev' type-id='35ed8932' visibility='default'/>
	+ <var-decl name='_IO_write_ptr' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='384'>
	- <var-decl name='st_size' type-id='79989e9c' visibility='default'/>
	+ <var-decl name='_IO_write_end' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='448'>
	- <var-decl name='st_blksize' type-id='d3f10a7f' visibility='default'/>
	+ <var-decl name='_IO_buf_base' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='512'>
	- <var-decl name='st_blocks' type-id='dbc43803' visibility='default'/>
	+ <var-decl name='_IO_buf_end' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='576'>
	- <var-decl name='st_atim' type-id='a9c79a1f' visibility='default'/>
	+ <var-decl name='_IO_save_base' type-id='26a90f95' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='640'>
	+ <var-decl name='_IO_backup_base' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='704'>
	- <var-decl name='st_mtim' type-id='a9c79a1f' visibility='default'/>
	+ <var-decl name='_IO_save_end' type-id='26a90f95' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='768'>
	+ <var-decl name='_markers' type-id='e4c6fa61' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='832'>
	- <var-decl name='st_ctim' type-id='a9c79a1f' visibility='default'/>
	+ <var-decl name='_chain' type-id='dca988a5' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='896'>
	+ <var-decl name='_fileno' type-id='95e97e5e' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='928'>
	+ <var-decl name='_flags2' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='960'>
	- <var-decl name='__unused' type-id='083f8d58' visibility='default'/>
	+ <var-decl name='_old_offset' type-id='79989e9c' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='1024'>
	+ <var-decl name='_cur_column' type-id='8efea9e5' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='1040'>
	+ <var-decl name='_vtable_offset' type-id='28577a57' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='1048'>
	+ <var-decl name='_shortbuf' type-id='89feb1ec' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='1088'>
	+ <var-decl name='_lock' type-id='cecf4ea7' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='1152'>
	+ <var-decl name='_offset' type-id='724e4de6' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='1216'>
	+ <var-decl name='_codecvt' type-id='570f8c59' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='1280'>
	+ <var-decl name='_wide_data' type-id='c65a1f29' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='1344'>
	+ <var-decl name='_freeres_list' type-id='dca988a5' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='1408'>
	+ <var-decl name='_freeres_buf' type-id='eaa32e2f' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='1472'>
	+ <var-decl name='__pad5' type-id='b59d7dce' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='1536'>
	+ <var-decl name='_mode' type-id='95e97e5e' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='1568'>
	+ <var-decl name='_unused2' type-id='664ac0b7' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='__ino_t' type-id='7359adad' id='e43e523d'/>
	- <typedef-decl name='__blkcnt_t' type-id='bd54fe1a' id='dbc43803'/>
	+ <class-decl name='timespec' size-in-bits='128' is-struct='yes' visibility='default' id='a9c79a1f'>
	+ <data-member access='public' layout-offset-in-bits='0'>
	+ <var-decl name='tv_sec' type-id='65eda9c0' visibility='default'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='64'>
	+ <var-decl name='tv_nsec' type-id='03085adc' visibility='default'/>
	+ </data-member>
	+ </class-decl>
	+ <typedef-decl name='DIR' type-id='20cd73f2' id='54a5d683'/>
	+ <typedef-decl name='uintptr_t' type-id='7359adad' id='e475ab95'/>
	<pointer-type-def type-id='54a5d683' size-in-bits='64' id='f09217ba'/>
	<pointer-type-def type-id='aa12d1ba' size-in-bits='64' id='822cd80b'/>
	+ <qualified-type-def type-id='822cd80b' restrict='yes' id='e75a27e9'/>
	<pointer-type-def type-id='ec1ed955' size-in-bits='64' id='dca988a5'/>
	+ <pointer-type-def type-id='a4036571' size-in-bits='64' id='570f8c59'/>
	<pointer-type-def type-id='bb4788fa' size-in-bits='64' id='cecf4ea7'/>
	<pointer-type-def type-id='010ae0b9' size-in-bits='64' id='e4c6fa61'/>
	+ <pointer-type-def type-id='79bd3751' size-in-bits='64' id='c65a1f29'/>
	<pointer-type-def type-id='d5027220' size-in-bits='64' id='b7f2d5e6'/>
	<pointer-type-def type-id='e4957c49' size-in-bits='64' id='924bbc81'/>
	<qualified-type-def type-id='924bbc81' const='yes' id='5499dcde'/>
	<pointer-type-def type-id='5499dcde' size-in-bits='64' id='2236d41c'/>
	+ <qualified-type-def type-id='2236d41c' restrict='yes' id='31488924'/>
	<pointer-type-def type-id='fba6cb51' size-in-bits='64' id='32adbf30'/>
	<pointer-type-def type-id='428b67b3' size-in-bits='64' id='bf311473'/>
	<pointer-type-def type-id='b351119f' size-in-bits='64' id='716943c7'/>
	<pointer-type-def type-id='f20fbd51' size-in-bits='64' id='a3681dea'/>
	<pointer-type-def type-id='a3681dea' size-in-bits='64' id='fce6d540'/>
	<pointer-type-def type-id='26a90f95' size-in-bits='64' id='9b23c9ad'/>
	+ <qualified-type-def type-id='9b23c9ad' restrict='yes' id='8c85230f'/>
	<qualified-type-def type-id='e4957c49' const='yes' id='fced9da2'/>
	<pointer-type-def type-id='fced9da2' size-in-bits='64' id='b20efd18'/>
	<qualified-type-def type-id='8b092c69' const='yes' id='1a21babe'/>
	<qualified-type-def type-id='8afd6070' const='yes' id='1d853360'/>
	<pointer-type-def type-id='1d853360' size-in-bits='64' id='c2afbd7e'/>
	<pointer-type-def type-id='5725d813' size-in-bits='64' id='07b96073'/>
	<pointer-type-def type-id='7a842a6b' size-in-bits='64' id='07ee4a58'/>
	+ <pointer-type-def type-id='2ec2411e' size-in-bits='64' id='6c16a6c8'/>
	<pointer-type-def type-id='96ee24a5' size-in-bits='64' id='585e1de9'/>
	<pointer-type-def type-id='8a70a786' size-in-bits='64' id='5507783b'/>
	<pointer-type-def type-id='857bb57e' size-in-bits='64' id='75be733c'/>
	<pointer-type-def type-id='de5d1d8f' size-in-bits='64' id='9eadf5e0'/>
	<pointer-type-def type-id='b1e62775' size-in-bits='64' id='f095e320'/>
	<pointer-type-def type-id='7d8569fd' size-in-bits='64' id='7347a39e'/>
	<pointer-type-def type-id='b7c58eaa' size-in-bits='64' id='e7c00489'/>
	<pointer-type-def type-id='519bc206' size-in-bits='64' id='ef2f159c'/>
	+ <qualified-type-def type-id='ef2f159c' restrict='yes' id='de0eb5a4'/>
	<pointer-type-def type-id='aafc373f' size-in-bits='64' id='4330df87'/>
	+ <qualified-type-def type-id='4330df87' restrict='yes' id='73665405'/>
	<pointer-type-def type-id='0bbec9cd' size-in-bits='64' id='62f7a03d'/>
	<pointer-type-def type-id='b1bbf10d' size-in-bits='64' id='9cf59a50'/>
	<pointer-type-def type-id='5d6479ae' size-in-bits='64' id='892b4acc'/>
	<pointer-type-def type-id='3502e3ff' size-in-bits='64' id='4dd26a40'/>
	- <pointer-type-def type-id='0d7551dc' size-in-bits='64' id='b4a8d2f6'/>
	+ <pointer-type-def type-id='f1abb096' size-in-bits='64' id='5f147c28'/>
	<pointer-type-def type-id='c5c76c9c' size-in-bits='64' id='b7f9d8e6'/>
	<pointer-type-def type-id='eaa32e2f' size-in-bits='64' id='63e171df'/>
	<qualified-type-def type-id='48b5725f' volatile='yes' id='b0b3cbf9'/>
	<pointer-type-def type-id='b0b3cbf9' size-in-bits='64' id='fe09dd29'/>
	- <function-decl name='slice_cache_compare' mangled-name='slice_cache_compare' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='slice_cache_compare'>
	- <parameter type-id='eaa32e2f' name='arg1'/>
	- <parameter type-id='eaa32e2f' name='arg2'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='zutil_alloc' mangled-name='zutil_alloc' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zutil_alloc'>
	- <parameter type-id='5507783b' name='hdl'/>
	- <parameter type-id='b59d7dce' name='size'/>
	- <return type-id='eaa32e2f'/>
	- </function-decl>
	- <function-decl name='zutil_strdup' mangled-name='zutil_strdup' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zutil_strdup'>
	- <parameter type-id='5507783b' name='hdl'/>
	- <parameter type-id='80f4b756' name='str'/>
	- <return type-id='26a90f95'/>
	- </function-decl>
	- <function-decl name='zpool_read_label' mangled-name='zpool_read_label' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_read_label'>
	- <parameter type-id='95e97e5e' name='fd'/>
	- <parameter type-id='857bb57e' name='config'/>
	- <parameter type-id='7292109c' name='num_labels'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='label_paths' mangled-name='label_paths' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='label_paths'>
	- <parameter type-id='5507783b' name='hdl'/>
	- <parameter type-id='5ce45b60' name='label'/>
	- <parameter type-id='9b23c9ad' name='path'/>
	- <parameter type-id='9b23c9ad' name='devid'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='zpool_search_import' mangled-name='zpool_search_import' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_search_import'>
	- <parameter type-id='eaa32e2f' name='hdl'/>
	- <parameter type-id='07ee4a58' name='import'/>
	- <parameter type-id='f095e320' name='pco'/>
	- <return type-id='5ce45b60'/>
	- </function-decl>
	- <function-decl name='zpool_find_config' mangled-name='zpool_find_config' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_find_config'>
	- <parameter type-id='eaa32e2f' name='hdl'/>
	- <parameter type-id='80f4b756' name='target'/>
	- <parameter type-id='857bb57e' name='configp'/>
	- <parameter type-id='07ee4a58' name='args'/>
	- <parameter type-id='f095e320' name='pco'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='vsnprintf' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='26a90f95'/>
	- <parameter type-id='b59d7dce'/>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='b7f2d5e6'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='fprintf' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='822cd80b'/>
	- <parameter type-id='80f4b756'/>
	- <parameter is-variadic='yes'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='exit' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='95e97e5e'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	- <function-decl name='nvlist_lookup_nvlist_array' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='5ce45b60'/>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='75be733c'/>
	- <parameter type-id='4dd26a40'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='nvlist_lookup_string' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='5ce45b60'/>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='9b23c9ad'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='nvlist_add_string' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='5ce45b60'/>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='80f4b756'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	+ <class-decl name='_IO_codecvt' is-struct='yes' visibility='default' is-declaration-only='yes' id='a4036571'/>
	+ <class-decl name='_IO_marker' is-struct='yes' visibility='default' is-declaration-only='yes' id='010ae0b9'/>
	+ <class-decl name='_IO_wide_data' is-struct='yes' visibility='default' is-declaration-only='yes' id='79bd3751'/>
	+ <class-decl name='__dirstream' is-struct='yes' visibility='default' is-declaration-only='yes' id='20cd73f2'/>
	<function-decl name='update_vdev_config_dev_strs' mangled-name='update_vdev_config_dev_strs' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='update_vdev_config_dev_strs'>
	<parameter type-id='5ce45b60'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='strncmp' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='b59d7dce'/>
	- <return type-id='95e97e5e'/>
	+ <function-decl name='update_vdevs_config_dev_sysfs_path' mangled-name='update_vdevs_config_dev_sysfs_path' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='update_vdevs_config_dev_sysfs_path'>
	+ <parameter type-id='5ce45b60'/>
	+ <return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='calloc' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='avl_create' mangled-name='avl_create' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='avl_create'>
	+ <parameter type-id='a3681dea'/>
	+ <parameter type-id='585e1de9'/>
	<parameter type-id='b59d7dce'/>
	<parameter type-id='b59d7dce'/>
	- <return type-id='eaa32e2f'/>
	- </function-decl>
	- <function-decl name='asprintf' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='9b23c9ad'/>
	- <parameter type-id='80f4b756'/>
	- <parameter is-variadic='yes'/>
	- <return type-id='95e97e5e'/>
	+ <return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='avl_find' mangled-name='avl_find' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='avl_find'>
	<parameter type-id='a3681dea'/>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='32adbf30'/>
	<return type-id='eaa32e2f'/>
	</function-decl>
	<function-decl name='avl_insert' mangled-name='avl_insert' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='avl_insert'>
	<parameter type-id='a3681dea'/>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='fba6cb51'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='realpath' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='26a90f95'/>
	- <return type-id='26a90f95'/>
	- </function-decl>
	- <function-decl name='opendir' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='80f4b756'/>
	- <return type-id='f09217ba'/>
	- </function-decl>
	- <function-decl name='readdir64' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='f09217ba'/>
	- <return type-id='07b96073'/>
	+ <function-decl name='avl_first' mangled-name='avl_first' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='avl_first'>
	+ <parameter type-id='a3681dea'/>
	+ <return type-id='eaa32e2f'/>
	</function-decl>
	- <function-decl name='closedir' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='f09217ba'/>
	- <return type-id='95e97e5e'/>
	+ <function-decl name='avl_destroy_nodes' mangled-name='avl_destroy_nodes' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='avl_destroy_nodes'>
	+ <parameter type-id='a3681dea'/>
	+ <parameter type-id='63e171df'/>
	+ <return type-id='eaa32e2f'/>
	</function-decl>
	- <function-decl name='strerror' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='95e97e5e'/>
	- <return type-id='26a90f95'/>
	+ <function-decl name='avl_destroy' mangled-name='avl_destroy' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='avl_destroy'>
	+ <parameter type-id='a3681dea'/>
	+ <return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='dcgettext' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='80f4b756'/>
	+ <function-decl name='avl_walk' mangled-name='avl_walk' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='avl_walk'>
	+ <parameter type-id='716943c7'/>
	+ <parameter type-id='eaa32e2f'/>
	<parameter type-id='95e97e5e'/>
	- <return type-id='26a90f95'/>
	- </function-decl>
	- <function-decl name='dirname' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='26a90f95'/>
	- <return type-id='26a90f95'/>
	+ <return type-id='eaa32e2f'/>
	</function-decl>
	<function-decl name='nvlist_alloc' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='857bb57e'/>
	<parameter type-id='3502e3ff'/>
	<parameter type-id='95e97e5e'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	+ <function-decl name='nvlist_dup' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='5ce45b60'/>
	+ <parameter type-id='857bb57e'/>
	+ <parameter type-id='95e97e5e'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	<function-decl name='nvlist_add_uint64' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='9c313c2d'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='nvlist_dup' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='nvlist_add_string' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='5ce45b60'/>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='80f4b756'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='nvlist_add_nvlist' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='5ce45b60'/>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='5ce45b60'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='nvlist_add_uint64_array' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='5ce45b60'/>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='5d6479ae'/>
	+ <parameter type-id='3502e3ff'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='nvlist_add_nvlist_array' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='5ce45b60'/>
	+ <parameter type-id='80f4b756'/>
	<parameter type-id='857bb57e'/>
	- <parameter type-id='95e97e5e'/>
	+ <parameter type-id='3502e3ff'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='nvlist_remove' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='8d0687d2'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	+ <function-decl name='nvlist_lookup_string' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='5ce45b60'/>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='9b23c9ad'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	<function-decl name='nvlist_lookup_uint64_array' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='892b4acc'/>
	<parameter type-id='4dd26a40'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='nvlist_add_uint64_array' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='nvlist_lookup_nvlist_array' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	- <parameter type-id='5d6479ae'/>
	- <parameter type-id='3502e3ff'/>
	+ <parameter type-id='75be733c'/>
	+ <parameter type-id='4dd26a40'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='nvlist_add_nvlist_array' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='nvlist_empty' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='5ce45b60'/>
	- <parameter type-id='80f4b756'/>
	+ <return type-id='c19b74c3'/>
	+ </function-decl>
	+ <function-decl name='nvpair_value_nvlist' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='3fa542f0'/>
	<parameter type-id='857bb57e'/>
	- <parameter type-id='3502e3ff'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='nvlist_add_nvlist' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='fnvlist_lookup_nvlist' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	- <parameter type-id='5ce45b60'/>
	- <return type-id='95e97e5e'/>
	+ <return type-id='5ce45b60'/>
	</function-decl>
	- <function-decl name='sysconf' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='95e97e5e'/>
	- <return type-id='bd54fe1a'/>
	+ <function-decl name='fnvpair_value_nvlist' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='3fa542f0'/>
	+ <return type-id='5ce45b60'/>
	</function-decl>
	<function-decl name='tpool_create' mangled-name='tpool_create' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='tpool_create'>
	<parameter type-id='3502e3ff'/>
	<parameter type-id='3502e3ff'/>
	<parameter type-id='3502e3ff'/>
	<parameter type-id='7347a39e'/>
	<return type-id='9cf59a50'/>
	</function-decl>
	- <function-decl name='avl_first' mangled-name='avl_first' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='avl_first'>
	- <parameter type-id='a3681dea'/>
	- <return type-id='eaa32e2f'/>
	- </function-decl>
	<function-decl name='tpool_dispatch' mangled-name='tpool_dispatch' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='tpool_dispatch'>
	<parameter type-id='9cf59a50'/>
	<parameter type-id='b7f9d8e6'/>
	<parameter type-id='eaa32e2f'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='avl_walk' mangled-name='avl_walk' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='avl_walk'>
	- <parameter type-id='716943c7'/>
	- <parameter type-id='eaa32e2f'/>
	- <parameter type-id='95e97e5e'/>
	- <return type-id='eaa32e2f'/>
	- </function-decl>
	- <function-decl name='tpool_wait' mangled-name='tpool_wait' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='tpool_wait'>
	+ <function-decl name='tpool_destroy' mangled-name='tpool_destroy' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='tpool_destroy'>
	<parameter type-id='9cf59a50'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='tpool_destroy' mangled-name='tpool_destroy' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='tpool_destroy'>
	+ <function-decl name='tpool_wait' mangled-name='tpool_wait' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='tpool_wait'>
	<parameter type-id='9cf59a50'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='avl_destroy_nodes' mangled-name='avl_destroy_nodes' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='avl_destroy_nodes'>
	- <parameter type-id='a3681dea'/>
	- <parameter type-id='63e171df'/>
	+ <function-decl name='spl_pagesize' mangled-name='spl_pagesize' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='spl_pagesize'>
	+ <return type-id='b59d7dce'/>
	+ </function-decl>
	+ <function-decl name='zutil_alloc' mangled-name='zutil_alloc' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zutil_alloc'>
	+ <parameter type-id='5507783b' name='hdl'/>
	+ <parameter type-id='b59d7dce' name='size'/>
	<return type-id='eaa32e2f'/>
	</function-decl>
	- <function-decl name='avl_destroy' mangled-name='avl_destroy' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='avl_destroy'>
	- <parameter type-id='a3681dea'/>
	- <return type-id='48b5725f'/>
	+ <function-decl name='zutil_strdup' mangled-name='zutil_strdup' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zutil_strdup'>
	+ <parameter type-id='5507783b' name='hdl'/>
	+ <parameter type-id='80f4b756' name='str'/>
	+ <return type-id='26a90f95'/>
	</function-decl>
	- <function-decl name='__fxstat64' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='95e97e5e'/>
	- <parameter type-id='95e97e5e'/>
	- <parameter type-id='62f7a03d'/>
	+ <function-decl name='zpool_read_label' mangled-name='zpool_read_label' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_read_label'>
	+ <parameter type-id='95e97e5e' name='fd'/>
	+ <parameter type-id='857bb57e' name='config'/>
	+ <parameter type-id='7292109c' name='num_labels'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='ioctl' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='95e97e5e'/>
	- <parameter type-id='7359adad'/>
	- <parameter is-variadic='yes'/>
	+ <function-decl name='slice_cache_compare' mangled-name='slice_cache_compare' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='slice_cache_compare'>
	+ <parameter type-id='eaa32e2f' name='arg1'/>
	+ <parameter type-id='eaa32e2f' name='arg2'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='pread64' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='95e97e5e'/>
	- <parameter type-id='eaa32e2f'/>
	- <parameter type-id='b59d7dce'/>
	- <parameter type-id='724e4de6'/>
	- <return type-id='79a0948f'/>
	+ <function-decl name='label_paths' mangled-name='label_paths' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='label_paths'>
	+ <parameter type-id='5507783b' name='hdl'/>
	+ <parameter type-id='5ce45b60' name='label'/>
	+ <parameter type-id='9b23c9ad' name='path'/>
	+ <parameter type-id='9b23c9ad' name='devid'/>
	+ <return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='spl_pagesize' mangled-name='spl_pagesize' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='spl_pagesize'>
	- <return type-id='b59d7dce'/>
	+ <function-decl name='zpool_search_import' mangled-name='zpool_search_import' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_search_import'>
	+ <parameter type-id='eaa32e2f' name='hdl'/>
	+ <parameter type-id='07ee4a58' name='import'/>
	+ <parameter type-id='f095e320' name='pco'/>
	+ <return type-id='5ce45b60'/>
	</function-decl>
	- <function-decl name='posix_memalign' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='63e171df'/>
	- <parameter type-id='b59d7dce'/>
	- <parameter type-id='b59d7dce'/>
	+ <function-decl name='zpool_find_config' mangled-name='zpool_find_config' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_find_config'>
	+ <parameter type-id='eaa32e2f' name='hdl'/>
	+ <parameter type-id='80f4b756' name='target'/>
	+ <parameter type-id='857bb57e' name='configp'/>
	+ <parameter type-id='07ee4a58' name='args'/>
	+ <parameter type-id='f095e320' name='pco'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='avl_create' mangled-name='avl_create' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='avl_create'>
	- <parameter type-id='a3681dea'/>
	- <parameter type-id='585e1de9'/>
	- <parameter type-id='b59d7dce'/>
	- <parameter type-id='b59d7dce'/>
	+ <function-decl name='for_each_vdev_cb' mangled-name='for_each_vdev_cb' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='for_each_vdev_cb'>
	+ <parameter type-id='eaa32e2f' name='zhp'/>
	+ <parameter type-id='5ce45b60' name='nv'/>
	+ <parameter type-id='dff793e0' name='func'/>
	+ <parameter type-id='eaa32e2f' name='data'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='for_each_vdev_in_nvlist' mangled-name='for_each_vdev_in_nvlist' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='for_each_vdev_in_nvlist'>
	+ <parameter type-id='5ce45b60' name='nvroot'/>
	+ <parameter type-id='dff793e0' name='func'/>
	+ <parameter type-id='eaa32e2f' name='data'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='zpool_find_import_blkid' mangled-name='zpool_find_import_blkid' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_find_import_blkid'>
	+ <parameter type-id='5507783b'/>
	+ <parameter type-id='18c91f9e'/>
	+ <parameter type-id='fce6d540'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='zpool_open_func' mangled-name='zpool_open_func' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_open_func'>
	+ <parameter type-id='eaa32e2f'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='fnvlist_lookup_nvlist' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='5ce45b60'/>
	+ <function-decl name='opendir' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='80f4b756'/>
	- <return type-id='5ce45b60'/>
	+ <return type-id='f09217ba'/>
	+ </function-decl>
	+ <function-decl name='closedir' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='f09217ba'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='readdir64' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='f09217ba'/>
	+ <return type-id='07b96073'/>
	+ </function-decl>
	+ <function-decl name='dirname' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='26a90f95'/>
	+ <return type-id='26a90f95'/>
	+ </function-decl>
	+ <function-decl name='__xpg_basename' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='26a90f95'/>
	+ <return type-id='26a90f95'/>
	+ </function-decl>
	+ <function-decl name='dcgettext' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='95e97e5e'/>
	+ <return type-id='26a90f95'/>
	</function-decl>
	<function-decl name='pthread_mutex_init' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='18c91f9e'/>
	<parameter type-id='c2afbd7e'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='pthread_mutex_destroy' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='18c91f9e'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='fnvpair_value_nvlist' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='3fa542f0'/>
	- <return type-id='5ce45b60'/>
	+ <function-decl name='fprintf' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='e75a27e9'/>
	+ <parameter type-id='9d26089a'/>
	+ <parameter is-variadic='yes'/>
	+ <return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='__xpg_basename' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='vsnprintf' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='26a90f95'/>
	- <return type-id='26a90f95'/>
	+ <parameter type-id='b59d7dce'/>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='b7f2d5e6'/>
	+ <return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zpool_find_import_blkid' mangled-name='zpool_find_import_blkid' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_find_import_blkid'>
	- <parameter type-id='5507783b'/>
	- <parameter type-id='18c91f9e'/>
	- <parameter type-id='fce6d540'/>
	+ <function-decl name='asprintf' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='8c85230f'/>
	+ <parameter type-id='9d26089a'/>
	+ <parameter is-variadic='yes'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='nvlist_empty' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='5ce45b60'/>
	- <return type-id='c19b74c3'/>
	+ <function-decl name='strtoull' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='9d26089a'/>
	+ <parameter type-id='8c85230f'/>
	+ <parameter type-id='95e97e5e'/>
	+ <return type-id='3a47d82b'/>
	</function-decl>
	- <function-decl name='geteuid' visibility='default' binding='global' size-in-bits='64'>
	- <return type-id='cc5fcceb'/>
	+ <function-decl name='calloc' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='b59d7dce'/>
	+ <parameter type-id='b59d7dce'/>
	+ <return type-id='eaa32e2f'/>
	</function-decl>
	- <function-decl name='nvpair_value_nvlist' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='3fa542f0'/>
	- <parameter type-id='857bb57e'/>
	+ <function-decl name='posix_memalign' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='63e171df'/>
	+ <parameter type-id='b59d7dce'/>
	+ <parameter type-id='b59d7dce'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='strtoull' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='exit' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='95e97e5e'/>
	+ <return type-id='48b5725f'/>
	+ </function-decl>
	+ <function-decl name='realpath' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='9d26089a'/>
	+ <parameter type-id='266fe297'/>
	+ <return type-id='26a90f95'/>
	+ </function-decl>
	+ <function-decl name='strncmp' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='80f4b756'/>
	- <parameter type-id='9b23c9ad'/>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='b59d7dce'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='strpbrk' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='80f4b756'/>
	+ <return type-id='26a90f95'/>
	+ </function-decl>
	+ <function-decl name='strerror' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='95e97e5e'/>
	- <return type-id='3a47d82b'/>
	+ <return type-id='26a90f95'/>
	+ </function-decl>
	+ <function-decl name='ioctl' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='95e97e5e'/>
	+ <parameter type-id='7359adad'/>
	+ <parameter is-variadic='yes'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='fstat64' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='95e97e5e'/>
	+ <parameter type-id='62f7a03d'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='pread64' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='95e97e5e'/>
	+ <parameter type-id='eaa32e2f'/>
	+ <parameter type-id='b59d7dce'/>
	+ <parameter type-id='724e4de6'/>
	+ <return type-id='79a0948f'/>
	+ </function-decl>
	+ <function-decl name='sysconf' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='95e97e5e'/>
	+ <return type-id='bd54fe1a'/>
	+ </function-decl>
	+ <function-decl name='geteuid' visibility='default' binding='global' size-in-bits='64'>
	+ <return type-id='cc5fcceb'/>
	</function-decl>
	<function-type size-in-bits='64' id='baa42fef'>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='9c313c2d'/>
	<parameter type-id='37e3bd22'/>
	<return type-id='95e97e5e'/>
	</function-type>
	+ <function-type size-in-bits='64' id='2ec2411e'>
	+ <parameter type-id='eaa32e2f'/>
	+ <parameter type-id='5ce45b60'/>
	+ <parameter type-id='eaa32e2f'/>
	+ <return type-id='95e97e5e'/>
	+ </function-type>
	<function-type size-in-bits='64' id='96ee24a5'>
	- <parameter type-id='eaa32e2f' name='arg1'/>
	- <parameter type-id='eaa32e2f' name='arg2'/>
	+ <parameter type-id='eaa32e2f'/>
	+ <parameter type-id='eaa32e2f'/>
	<return type-id='95e97e5e'/>
	</function-type>
	<function-type size-in-bits='64' id='29f040d2'>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='5ce45b60'/>
	<return type-id='5ce45b60'/>
	</function-type>
	- <function-type size-in-bits='64' id='0d7551dc'>
	- <parameter type-id='95506cfb'/>
	- <return type-id='48b5725f'/>
	- </function-type>
	- <function-type size-in-bits='64' id='c5c76c9c'>
	- <parameter type-id='eaa32e2f'/>
	+ <function-type size-in-bits='64' id='f1abb096'>
	+ <parameter type-id='eabacd01'/>
	<return type-id='48b5725f'/>
	</function-type>
	</abi-instr>
	- <abi-instr version='1.0' address-size='64' path='zutil_nicenum.c' language='LANG_C89'>
	+ <abi-instr address-size='64' path='zutil_nicenum.c' language='LANG_C99'>
	<type-decl name='double' size-in-bits='64' id='a0eb0f08'/>
	<type-decl name='long double' size-in-bits='128' id='e095c704'/>
	<enum-decl name='zfs_nicenum_format' id='29cf1969'>
	<underlying-type type-id='9cac1fee'/>
	<enumerator name='ZFS_NICENUM_1024' value='0'/>
	<enumerator name='ZFS_NICENUM_BYTES' value='1'/>
	<enumerator name='ZFS_NICENUM_TIME' value='2'/>
	<enumerator name='ZFS_NICENUM_RAW' value='3'/>
	<enumerator name='ZFS_NICENUM_RAWTIME' value='4'/>
	</enum-decl>
	<qualified-type-def type-id='8efea9e5' const='yes' id='3beb2af4'/>
	<pointer-type-def type-id='3beb2af4' size-in-bits='64' id='31347b7a'/>
	<pointer-type-def type-id='31347b7a' size-in-bits='64' id='c59e1ef0'/>
	<function-decl name='zfs_isnumber' mangled-name='zfs_isnumber' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_isnumber'>
	<parameter type-id='80f4b756' name='str'/>
	<return type-id='c19b74c3'/>
	</function-decl>
	<function-decl name='zfs_nicenum_format' mangled-name='zfs_nicenum_format' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_nicenum_format'>
	<parameter type-id='9c313c2d' name='num'/>
	<parameter type-id='26a90f95' name='buf'/>
	<parameter type-id='b59d7dce' name='buflen'/>
	<parameter type-id='29cf1969' name='format'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='zfs_nicenum' mangled-name='zfs_nicenum' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_nicenum'>
	<parameter type-id='9c313c2d' name='num'/>
	<parameter type-id='26a90f95' name='buf'/>
	<parameter type-id='b59d7dce' name='buflen'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='zfs_nicetime' mangled-name='zfs_nicetime' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_nicetime'>
	<parameter type-id='9c313c2d' name='num'/>
	<parameter type-id='26a90f95' name='buf'/>
	<parameter type-id='b59d7dce' name='buflen'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='zfs_niceraw' mangled-name='zfs_niceraw' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_niceraw'>
	<parameter type-id='9c313c2d' name='num'/>
	<parameter type-id='26a90f95' name='buf'/>
	<parameter type-id='b59d7dce' name='buflen'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='zfs_nicebytes' mangled-name='zfs_nicebytes' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_nicebytes'>
	<parameter type-id='9c313c2d' name='num'/>
	<parameter type-id='26a90f95' name='buf'/>
	<parameter type-id='b59d7dce' name='buflen'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='__ctype_b_loc' visibility='default' binding='global' size-in-bits='64'>
	- <return type-id='c59e1ef0'/>
	- </function-decl>
	<function-decl name='powl' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='e095c704'/>
	<parameter type-id='e095c704'/>
	<return type-id='e095c704'/>
	</function-decl>
	<function-decl name='floor' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='a0eb0f08'/>
	<return type-id='a0eb0f08'/>
	</function-decl>
	+ <function-decl name='__ctype_b_loc' visibility='default' binding='global' size-in-bits='64'>
	+ <return type-id='c59e1ef0'/>
	+ </function-decl>
	</abi-instr>
	- <abi-instr version='1.0' address-size='64' path='zutil_pool.c' language='LANG_C89'>
	+ <abi-instr address-size='64' path='zutil_pool.c' language='LANG_C99'>
	<array-type-def dimensions='1' type-id='853fd5dc' size-in-bits='32768' id='b505fc2f'>
	- <subrange length='64' type-id='4c87fef4' id='b10be967'/>
	+ <subrange length='64' type-id='7359adad' id='b10be967'/>
	</array-type-def>
	- <typedef-decl name='ddt_stat_t' type-id='65242dfe' id='853fd5dc'/>
	<class-decl name='ddt_stat' size-in-bits='512' is-struct='yes' visibility='default' id='65242dfe'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='dds_blocks' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='dds_lsize' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='dds_psize' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	<var-decl name='dds_dsize' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='256'>
	<var-decl name='dds_ref_blocks' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='320'>
	<var-decl name='dds_ref_lsize' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='384'>
	<var-decl name='dds_ref_psize' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='448'>
	<var-decl name='dds_ref_dsize' type-id='9c313c2d' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='ddt_histogram_t' type-id='bc2b3086' id='2d7fe832'/>
	+ <typedef-decl name='ddt_stat_t' type-id='65242dfe' id='853fd5dc'/>
	<class-decl name='ddt_histogram' size-in-bits='32768' is-struct='yes' visibility='default' id='bc2b3086'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='ddh_stat' type-id='b505fc2f' visibility='default'/>
	</data-member>
	</class-decl>
	+ <typedef-decl name='ddt_histogram_t' type-id='bc2b3086' id='2d7fe832'/>
	<qualified-type-def type-id='2d7fe832' const='yes' id='ec92d602'/>
	<pointer-type-def type-id='ec92d602' size-in-bits='64' id='932720f8'/>
	<qualified-type-def type-id='853fd5dc' const='yes' id='764c298c'/>
	<pointer-type-def type-id='764c298c' size-in-bits='64' id='dfe59052'/>
	<function-decl name='zpool_dump_ddt' mangled-name='zpool_dump_ddt' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_dump_ddt'>
	<parameter type-id='dfe59052' name='dds_total'/>
	<parameter type-id='932720f8' name='ddh'/>
	<return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='zpool_history_unpack' mangled-name='zpool_history_unpack' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_history_unpack'>
	<parameter type-id='26a90f95' name='buf'/>
	<parameter type-id='9c313c2d' name='bytes_read'/>
	<parameter type-id='5d6479ae' name='leftover'/>
	<parameter type-id='75be733c' name='records'/>
	<parameter type-id='4dd26a40' name='numrecords'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='printf' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='80f4b756'/>
	<parameter is-variadic='yes'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='realloc' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='eaa32e2f'/>
	<parameter type-id='b59d7dce'/>
	<return type-id='eaa32e2f'/>
	</function-decl>
	</abi-instr>
	</abi-corpus>
	diff --git a/sys/contrib/openzfs/lib/libzfsbootenv/libzfsbootenv.abi b/sys/contrib/openzfs/lib/libzfsbootenv/libzfsbootenv.abi
	index 805223708ec7..0ddd41d0630e 100644
	--- a/sys/contrib/openzfs/lib/libzfsbootenv/libzfsbootenv.abi
	+++ b/sys/contrib/openzfs/lib/libzfsbootenv/libzfsbootenv.abi
	@@ -1,560 +1,577 @@
	-<abi-corpus architecture='elf-amd-x86_64' soname='libzfsbootenv.so.1'>
	+<abi-corpus version='2.0' architecture='elf-amd-x86_64' soname='libzfsbootenv.so.1'>
	<elf-needed>
	<dependency name='libzfs.so.4'/>
	<dependency name='libzfs_core.so.3'/>
	<dependency name='libuuid.so.1'/>
	- <dependency name='librt.so.1'/>
	<dependency name='libblkid.so.1'/>
	<dependency name='libudev.so.1'/>
	<dependency name='libuutil.so.3'/>
	<dependency name='libm.so.6'/>
	- <dependency name='libcrypto.so.10'/>
	+ <dependency name='libcrypto.so.1.1'/>
	<dependency name='libz.so.1'/>
	<dependency name='libnvpair.so.3'/>
	- <dependency name='libpthread.so.0'/>
	+ <dependency name='libtirpc.so.3'/>
	<dependency name='libc.so.6'/>
	</elf-needed>
	<elf-function-symbols>
	- <elf-symbol name='_fini' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	- <elf-symbol name='_init' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='lzbe_add_pair' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='lzbe_bootenv_print' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='lzbe_get_boot_device' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='lzbe_nvlist_free' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='lzbe_nvlist_get' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='lzbe_nvlist_set' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='lzbe_remove_pair' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='lzbe_set_boot_device' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	</elf-function-symbols>
	- <abi-instr version='1.0' address-size='64' path='lzbe_device.c' language='LANG_C89'>
	+ <abi-instr address-size='64' path='lzbe_device.c' language='LANG_C99'>
	<type-decl name='char' size-in-bits='8' id='a84c031d'/>
	<array-type-def dimensions='1' type-id='a84c031d' size-in-bits='8' id='89feb1ec'>
	- <subrange length='1' type-id='4c87fef4' id='52f813b4'/>
	+ <subrange length='1' type-id='7359adad' id='52f813b4'/>
	</array-type-def>
	<array-type-def dimensions='1' type-id='a84c031d' size-in-bits='160' id='664ac0b7'>
	- <subrange length='20' type-id='4c87fef4' id='fdca39cf'/>
	+ <subrange length='20' type-id='7359adad' id='fdca39cf'/>
	</array-type-def>
	+ <class-decl name='_IO_codecvt' is-struct='yes' visibility='default' is-declaration-only='yes' id='a4036571'/>
	+ <class-decl name='_IO_marker' is-struct='yes' visibility='default' is-declaration-only='yes' id='010ae0b9'/>
	+ <class-decl name='_IO_wide_data' is-struct='yes' visibility='default' is-declaration-only='yes' id='79bd3751'/>
	<class-decl name='libzfs_handle' is-struct='yes' visibility='default' is-declaration-only='yes' id='c8a9d9d8'/>
	<class-decl name='zpool_handle' is-struct='yes' visibility='default' is-declaration-only='yes' id='67002a8a'/>
	<type-decl name='int' size-in-bits='32' id='95e97e5e'/>
	<type-decl name='long int' size-in-bits='64' id='bd54fe1a'/>
	<type-decl name='signed char' size-in-bits='8' id='28577a57'/>
	- <type-decl name='sizetype' size-in-bits='64' id='4c87fef4'/>
	<type-decl name='unnamed-enum-underlying-type-32' is-anonymous='yes' size-in-bits='32' alignment-in-bits='32' id='9cac1fee'/>
	<type-decl name='unsigned int' size-in-bits='32' id='f0981eeb'/>
	<type-decl name='unsigned long int' size-in-bits='64' id='7359adad'/>
	<type-decl name='unsigned short int' size-in-bits='16' id='8efea9e5'/>
	<type-decl name='variadic parameter type' id='2c1145c5'/>
	<type-decl name='void' id='48b5725f'/>
	- <typedef-decl name='lzbe_flags_t' type-id='2b77720b' id='a1936f04'/>
	+ <typedef-decl name='zpool_handle_t' type-id='67002a8a' id='b1efc708'/>
	+ <typedef-decl name='libzfs_handle_t' type-id='c8a9d9d8' id='95942d0c'/>
	<enum-decl name='lzbe_flags' id='2b77720b'>
	<underlying-type type-id='9cac1fee'/>
	<enumerator name='lzbe_add' value='0'/>
	<enumerator name='lzbe_replace' value='1'/>
	</enum-decl>
	- <typedef-decl name='libzfs_handle_t' type-id='c8a9d9d8' id='95942d0c'/>
	- <typedef-decl name='zpool_handle_t' type-id='67002a8a' id='b1efc708'/>
	- <typedef-decl name='nvlist_t' type-id='ac266fd9' id='8e8d4be3'/>
	+ <typedef-decl name='lzbe_flags_t' type-id='2b77720b' id='a1936f04'/>
	<class-decl name='nvlist' size-in-bits='192' is-struct='yes' visibility='default' id='ac266fd9'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='nvl_version' type-id='3ff5601b' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='32'>
	<var-decl name='nvl_nvflag' type-id='8f92235e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='nvl_priv' type-id='9c313c2d' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='nvl_flag' type-id='8f92235e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='160'>
	<var-decl name='nvl_pad' type-id='3ff5601b' visibility='default'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='int32_t' type-id='95e97e5e' id='3ff5601b'/>
	- <typedef-decl name='uint32_t' type-id='f0981eeb' id='8f92235e'/>
	- <typedef-decl name='uint64_t' type-id='7359adad' id='9c313c2d'/>
	- <typedef-decl name='boolean_t' type-id='08f5ca17' id='c19b74c3'/>
	- <enum-decl name='__anonymous_enum__' is-anonymous='yes' id='08f5ca17'>
	+ <typedef-decl name='nvlist_t' type-id='ac266fd9' id='8e8d4be3'/>
	+ <enum-decl name='boolean_t' naming-typedef-id='c19b74c3' id='f58c8277'>
	<underlying-type type-id='9cac1fee'/>
	<enumerator name='B_FALSE' value='0'/>
	<enumerator name='B_TRUE' value='1'/>
	</enum-decl>
	+ <typedef-decl name='boolean_t' type-id='f58c8277' id='c19b74c3'/>
	+ <typedef-decl name='int32_t' type-id='33f57a65' id='3ff5601b'/>
	+ <typedef-decl name='uint32_t' type-id='62f1140c' id='8f92235e'/>
	+ <typedef-decl name='uint64_t' type-id='8910171f' id='9c313c2d'/>
	+ <typedef-decl name='__int32_t' type-id='95e97e5e' id='33f57a65'/>
	+ <typedef-decl name='__uint32_t' type-id='f0981eeb' id='62f1140c'/>
	+ <typedef-decl name='__uint64_t' type-id='7359adad' id='8910171f'/>
	+ <typedef-decl name='__off_t' type-id='bd54fe1a' id='79989e9c'/>
	+ <typedef-decl name='__off64_t' type-id='bd54fe1a' id='724e4de6'/>
	<typedef-decl name='FILE' type-id='ec1ed955' id='aa12d1ba'/>
	+ <typedef-decl name='_IO_lock_t' type-id='48b5725f' id='bb4788fa'/>
	<class-decl name='_IO_FILE' size-in-bits='1728' is-struct='yes' visibility='default' id='ec1ed955'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='_flags' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='_IO_read_ptr' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='_IO_read_end' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	<var-decl name='_IO_read_base' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='256'>
	<var-decl name='_IO_write_base' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='320'>
	<var-decl name='_IO_write_ptr' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='384'>
	<var-decl name='_IO_write_end' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='448'>
	<var-decl name='_IO_buf_base' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='512'>
	<var-decl name='_IO_buf_end' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='576'>
	<var-decl name='_IO_save_base' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='640'>
	<var-decl name='_IO_backup_base' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='704'>
	<var-decl name='_IO_save_end' type-id='26a90f95' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='768'>
	<var-decl name='_markers' type-id='e4c6fa61' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='832'>
	<var-decl name='_chain' type-id='dca988a5' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='896'>
	<var-decl name='_fileno' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='928'>
	<var-decl name='_flags2' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='960'>
	<var-decl name='_old_offset' type-id='79989e9c' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='1024'>
	<var-decl name='_cur_column' type-id='8efea9e5' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='1040'>
	<var-decl name='_vtable_offset' type-id='28577a57' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='1048'>
	<var-decl name='_shortbuf' type-id='89feb1ec' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='1088'>
	<var-decl name='_lock' type-id='cecf4ea7' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='1152'>
	<var-decl name='_offset' type-id='724e4de6' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='1216'>
	- <var-decl name='__pad1' type-id='eaa32e2f' visibility='default'/>
	+ <var-decl name='_codecvt' type-id='570f8c59' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='1280'>
	- <var-decl name='__pad2' type-id='eaa32e2f' visibility='default'/>
	+ <var-decl name='_wide_data' type-id='c65a1f29' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='1344'>
	- <var-decl name='__pad3' type-id='eaa32e2f' visibility='default'/>
	+ <var-decl name='_freeres_list' type-id='dca988a5' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='1408'>
	- <var-decl name='__pad4' type-id='eaa32e2f' visibility='default'/>
	+ <var-decl name='_freeres_buf' type-id='eaa32e2f' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='1472'>
	<var-decl name='__pad5' type-id='b59d7dce' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='1536'>
	<var-decl name='_mode' type-id='95e97e5e' visibility='default'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='1568'>
	<var-decl name='_unused2' type-id='664ac0b7' visibility='default'/>
	</data-member>
	</class-decl>
	- <class-decl name='_IO_marker' size-in-bits='192' is-struct='yes' visibility='default' id='010ae0b9'>
	- <data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='_next' type-id='e4c6fa61' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='_sbuf' type-id='dca988a5' visibility='default'/>
	- </data-member>
	- <data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='_pos' type-id='95e97e5e' visibility='default'/>
	- </data-member>
	- </class-decl>
	- <typedef-decl name='__off_t' type-id='bd54fe1a' id='79989e9c'/>
	- <typedef-decl name='_IO_lock_t' type-id='48b5725f' id='bb4788fa'/>
	- <typedef-decl name='__off64_t' type-id='bd54fe1a' id='724e4de6'/>
	<typedef-decl name='size_t' type-id='7359adad' id='b59d7dce'/>
	<pointer-type-def type-id='aa12d1ba' size-in-bits='64' id='822cd80b'/>
	+ <qualified-type-def type-id='822cd80b' restrict='yes' id='e75a27e9'/>
	<pointer-type-def type-id='ec1ed955' size-in-bits='64' id='dca988a5'/>
	+ <pointer-type-def type-id='a4036571' size-in-bits='64' id='570f8c59'/>
	<pointer-type-def type-id='bb4788fa' size-in-bits='64' id='cecf4ea7'/>
	<pointer-type-def type-id='010ae0b9' size-in-bits='64' id='e4c6fa61'/>
	+ <pointer-type-def type-id='79bd3751' size-in-bits='64' id='c65a1f29'/>
	<pointer-type-def type-id='a84c031d' size-in-bits='64' id='26a90f95'/>
	<pointer-type-def type-id='26a90f95' size-in-bits='64' id='9b23c9ad'/>
	+ <qualified-type-def type-id='9b23c9ad' restrict='yes' id='8c85230f'/>
	<qualified-type-def type-id='a84c031d' const='yes' id='9b45d938'/>
	<pointer-type-def type-id='9b45d938' size-in-bits='64' id='80f4b756'/>
	+ <qualified-type-def type-id='80f4b756' restrict='yes' id='9d26089a'/>
	<qualified-type-def type-id='8e8d4be3' const='yes' id='693c3853'/>
	<pointer-type-def type-id='693c3853' size-in-bits='64' id='22cce67b'/>
	<pointer-type-def type-id='95942d0c' size-in-bits='64' id='b0382bb3'/>
	<pointer-type-def type-id='8e8d4be3' size-in-bits='64' id='5ce45b60'/>
	<pointer-type-def type-id='5ce45b60' size-in-bits='64' id='857bb57e'/>
	<pointer-type-def type-id='9c313c2d' size-in-bits='64' id='5d6479ae'/>
	<pointer-type-def type-id='48b5725f' size-in-bits='64' id='eaa32e2f'/>
	<pointer-type-def type-id='b1efc708' size-in-bits='64' id='4c81de99'/>
	- <function-decl name='lzbe_set_boot_device' mangled-name='lzbe_set_boot_device' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='lzbe_set_boot_device'>
	- <parameter type-id='80f4b756' name='pool'/>
	- <parameter type-id='a1936f04' name='flag'/>
	- <parameter type-id='80f4b756' name='device'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='lzbe_get_boot_device' mangled-name='lzbe_get_boot_device' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='lzbe_get_boot_device'>
	- <parameter type-id='80f4b756' name='pool'/>
	- <parameter type-id='9b23c9ad' name='device'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	+ <class-decl name='_IO_codecvt' is-struct='yes' visibility='default' is-declaration-only='yes' id='a4036571'/>
	+ <class-decl name='_IO_marker' is-struct='yes' visibility='default' is-declaration-only='yes' id='010ae0b9'/>
	+ <class-decl name='_IO_wide_data' is-struct='yes' visibility='default' is-declaration-only='yes' id='79bd3751'/>
	+ <class-decl name='libzfs_handle' is-struct='yes' visibility='default' is-declaration-only='yes' id='c8a9d9d8'/>
	+ <class-decl name='zpool_handle' is-struct='yes' visibility='default' is-declaration-only='yes' id='67002a8a'/>
	<function-decl name='libzfs_init' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='b0382bb3'/>
	</function-decl>
	+ <function-decl name='libzfs_fini' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='b0382bb3'/>
	+ <return type-id='48b5725f'/>
	+ </function-decl>
	+ <function-decl name='libzfs_error_description' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='b0382bb3'/>
	+ <return type-id='80f4b756'/>
	+ </function-decl>
	<function-decl name='zpool_open' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='b0382bb3'/>
	<parameter type-id='80f4b756'/>
	<return type-id='4c81de99'/>
	</function-decl>
	- <function-decl name='fnvlist_alloc' visibility='default' binding='global' size-in-bits='64'>
	- <return type-id='5ce45b60'/>
	+ <function-decl name='zpool_close' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='4c81de99'/>
	+ <return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='fnvlist_add_uint64' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='zpool_set_bootenv' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='4c81de99'/>
	+ <parameter type-id='22cce67b'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='zpool_get_bootenv' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='4c81de99'/>
	+ <parameter type-id='857bb57e'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='nvlist_free' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='5ce45b60'/>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='9c313c2d'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='nvlist_exists' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='nvlist_lookup_uint64' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	- <return type-id='c19b74c3'/>
	+ <parameter type-id='5d6479ae'/>
	+ <return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='zpool_set_bootenv' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='4c81de99'/>
	- <parameter type-id='22cce67b'/>
	+ <function-decl name='nvlist_lookup_string' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='5ce45b60'/>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='9b23c9ad'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='fnvlist_free' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='nvlist_exists' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='5ce45b60'/>
	- <return type-id='48b5725f'/>
	+ <parameter type-id='80f4b756'/>
	+ <return type-id='c19b74c3'/>
	</function-decl>
	- <function-decl name='zpool_close' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='4c81de99'/>
	- <return type-id='48b5725f'/>
	+ <function-decl name='fnvlist_alloc' visibility='default' binding='global' size-in-bits='64'>
	+ <return type-id='5ce45b60'/>
	</function-decl>
	- <function-decl name='libzfs_fini' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='b0382bb3'/>
	+ <function-decl name='fnvlist_free' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='5ce45b60'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='asprintf' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='9b23c9ad'/>
	+ <function-decl name='fnvlist_add_uint64' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	- <parameter is-variadic='yes'/>
	- <return type-id='95e97e5e'/>
	+ <parameter type-id='9c313c2d'/>
	+ <return type-id='48b5725f'/>
	</function-decl>
	<function-decl name='fnvlist_add_string' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='80f4b756'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='free' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='eaa32e2f'/>
	+ <function-decl name='fnvlist_remove' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='5ce45b60'/>
	+ <parameter type-id='80f4b756'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='zpool_get_bootenv' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='4c81de99'/>
	- <parameter type-id='857bb57e'/>
	+ <function-decl name='lzbe_set_boot_device' mangled-name='lzbe_set_boot_device' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='lzbe_set_boot_device'>
	+ <parameter type-id='80f4b756' name='pool'/>
	+ <parameter type-id='a1936f04' name='flag'/>
	+ <parameter type-id='80f4b756' name='device'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='nvlist_lookup_uint64' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='5ce45b60'/>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='5d6479ae'/>
	+ <function-decl name='lzbe_get_boot_device' mangled-name='lzbe_get_boot_device' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='lzbe_get_boot_device'>
	+ <parameter type-id='80f4b756' name='pool'/>
	+ <parameter type-id='9b23c9ad' name='device'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='libzfs_error_description' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='b0382bb3'/>
	- <return type-id='80f4b756'/>
	- </function-decl>
	<function-decl name='fprintf' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='822cd80b'/>
	- <parameter type-id='80f4b756'/>
	+ <parameter type-id='e75a27e9'/>
	+ <parameter type-id='9d26089a'/>
	<parameter is-variadic='yes'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='fnvlist_remove' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='5ce45b60'/>
	- <parameter type-id='80f4b756'/>
	+ <function-decl name='asprintf' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='8c85230f'/>
	+ <parameter type-id='9d26089a'/>
	+ <parameter is-variadic='yes'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='free' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='eaa32e2f'/>
	<return type-id='48b5725f'/>
	</function-decl>
	- <function-decl name='strlen' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='strncmp' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='80f4b756'/>
	- <return type-id='b59d7dce'/>
	- </function-decl>
	- <function-decl name='nvlist_lookup_string' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	- <parameter type-id='9b23c9ad'/>
	+ <parameter type-id='b59d7dce'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='nvlist_free' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='5ce45b60'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	- <function-decl name='__strdup' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='strdup' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='80f4b756'/>
	<return type-id='26a90f95'/>
	</function-decl>
	+ <function-decl name='strlen' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='80f4b756'/>
	+ <return type-id='b59d7dce'/>
	+ </function-decl>
	</abi-instr>
	- <abi-instr version='1.0' address-size='64' path='lzbe_pair.c' language='LANG_C89'>
	+ <abi-instr address-size='64' path='lzbe_pair.c' language='LANG_C99'>
	<type-decl name='short int' size-in-bits='16' id='a2185560'/>
	<type-decl name='unsigned char' size-in-bits='8' id='002ac4a6'/>
	- <typedef-decl name='uint_t' type-id='f0981eeb' id='3502e3ff'/>
	- <typedef-decl name='uint8_t' type-id='002ac4a6' id='b96825af'/>
	- <typedef-decl name='int8_t' type-id='28577a57' id='ee31ee44'/>
	- <typedef-decl name='int64_t' type-id='bd54fe1a' id='9da381c4'/>
	- <typedef-decl name='uint16_t' type-id='8efea9e5' id='149c6638'/>
	- <typedef-decl name='int16_t' type-id='a2185560' id='23bd8cb5'/>
	<typedef-decl name='uchar_t' type-id='002ac4a6' id='d8bf0010'/>
	+ <typedef-decl name='uint_t' type-id='f0981eeb' id='3502e3ff'/>
	+ <typedef-decl name='int8_t' type-id='2171a512' id='ee31ee44'/>
	+ <typedef-decl name='int16_t' type-id='03896e23' id='23bd8cb5'/>
	+ <typedef-decl name='int64_t' type-id='0c9942d2' id='9da381c4'/>
	+ <typedef-decl name='uint8_t' type-id='c51d6389' id='b96825af'/>
	+ <typedef-decl name='uint16_t' type-id='253c2d2a' id='149c6638'/>
	+ <typedef-decl name='__int8_t' type-id='28577a57' id='2171a512'/>
	+ <typedef-decl name='__uint8_t' type-id='002ac4a6' id='c51d6389'/>
	+ <typedef-decl name='__int16_t' type-id='a2185560' id='03896e23'/>
	+ <typedef-decl name='__uint16_t' type-id='8efea9e5' id='253c2d2a'/>
	+ <typedef-decl name='__int64_t' type-id='bd54fe1a' id='0c9942d2'/>
	<pointer-type-def type-id='c19b74c3' size-in-bits='64' id='37e3bd22'/>
	<qualified-type-def type-id='26a90f95' const='yes' id='57de658a'/>
	<pointer-type-def type-id='57de658a' size-in-bits='64' id='f319fae0'/>
	<pointer-type-def type-id='23bd8cb5' size-in-bits='64' id='f76f73d0'/>
	<pointer-type-def type-id='3ff5601b' size-in-bits='64' id='4aafb922'/>
	<pointer-type-def type-id='9da381c4' size-in-bits='64' id='cb785ebf'/>
	<pointer-type-def type-id='ee31ee44' size-in-bits='64' id='256d5229'/>
	<pointer-type-def type-id='d8bf0010' size-in-bits='64' id='45b65157'/>
	<pointer-type-def type-id='149c6638' size-in-bits='64' id='8a121f49'/>
	<pointer-type-def type-id='8f92235e' size-in-bits='64' id='90421557'/>
	<pointer-type-def type-id='b96825af' size-in-bits='64' id='ae3e8ca6'/>
	<pointer-type-def type-id='eaa32e2f' size-in-bits='64' id='63e171df'/>
	- <function-decl name='lzbe_nvlist_get' mangled-name='lzbe_nvlist_get' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='lzbe_nvlist_get'>
	- <parameter type-id='80f4b756' name='pool'/>
	- <parameter type-id='80f4b756' name='key'/>
	- <parameter type-id='63e171df' name='ptr'/>
	- <return type-id='95e97e5e'/>
	- </function-decl>
	- <function-decl name='lzbe_nvlist_set' mangled-name='lzbe_nvlist_set' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='lzbe_nvlist_set'>
	- <parameter type-id='80f4b756' name='pool'/>
	- <parameter type-id='80f4b756' name='key'/>
	- <parameter type-id='eaa32e2f' name='ptr'/>
	+ <function-decl name='nvlist_alloc' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='857bb57e'/>
	+ <parameter type-id='3502e3ff'/>
	+ <parameter type-id='95e97e5e'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='lzbe_nvlist_free' mangled-name='lzbe_nvlist_free' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='lzbe_nvlist_free'>
	- <parameter type-id='eaa32e2f' name='ptr'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	- <function-decl name='lzbe_add_pair' mangled-name='lzbe_add_pair' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='lzbe_add_pair'>
	- <parameter type-id='eaa32e2f' name='ptr'/>
	- <parameter type-id='80f4b756' name='key'/>
	- <parameter type-id='80f4b756' name='type'/>
	- <parameter type-id='eaa32e2f' name='value'/>
	- <parameter type-id='b59d7dce' name='size'/>
	+ <function-decl name='nvlist_dup' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='5ce45b60'/>
	+ <parameter type-id='857bb57e'/>
	+ <parameter type-id='95e97e5e'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='lzbe_remove_pair' mangled-name='lzbe_remove_pair' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='lzbe_remove_pair'>
	- <parameter type-id='eaa32e2f' name='ptr'/>
	- <parameter type-id='80f4b756' name='key'/>
	+ <function-decl name='nvlist_add_boolean_value' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='5ce45b60'/>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='c19b74c3'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='nvlist_lookup_nvlist' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='nvlist_add_byte' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	- <parameter type-id='857bb57e'/>
	+ <parameter type-id='d8bf0010'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='nvlist_dup' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='nvlist_add_int8' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='5ce45b60'/>
	- <parameter type-id='857bb57e'/>
	- <parameter type-id='95e97e5e'/>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='ee31ee44'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='nvlist_alloc' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='857bb57e'/>
	- <parameter type-id='3502e3ff'/>
	- <parameter type-id='95e97e5e'/>
	+ <function-decl name='nvlist_add_uint8' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='5ce45b60'/>
	+ <parameter type-id='80f4b756'/>
	+ <parameter type-id='b96825af'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='nvlist_add_nvlist' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='nvlist_add_int16' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	- <parameter type-id='5ce45b60'/>
	+ <parameter type-id='23bd8cb5'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='nvlist_add_uint8_array' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='nvlist_add_uint16' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	- <parameter type-id='ae3e8ca6'/>
	- <parameter type-id='3502e3ff'/>
	+ <parameter type-id='149c6638'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='nvlist_add_int8_array' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='nvlist_add_int32' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	- <parameter type-id='256d5229'/>
	- <parameter type-id='3502e3ff'/>
	+ <parameter type-id='3ff5601b'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='nvlist_add_boolean_array' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='nvlist_add_uint32' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	- <parameter type-id='37e3bd22'/>
	- <parameter type-id='3502e3ff'/>
	+ <parameter type-id='8f92235e'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='nvlist_add_uint8' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='nvlist_add_int64' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	- <parameter type-id='b96825af'/>
	+ <parameter type-id='9da381c4'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='nvlist_add_int8' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='nvlist_add_uint64' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	- <parameter type-id='ee31ee44'/>
	+ <parameter type-id='9c313c2d'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='nvlist_add_boolean_value' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='nvlist_add_string' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	- <parameter type-id='c19b74c3'/>
	+ <parameter type-id='80f4b756'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='nvlist_add_nvlist_array' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='nvlist_add_nvlist' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	- <parameter type-id='857bb57e'/>
	- <parameter type-id='3502e3ff'/>
	+ <parameter type-id='5ce45b60'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='nvlist_add_string_array' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='nvlist_add_boolean_array' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	- <parameter type-id='f319fae0'/>
	+ <parameter type-id='37e3bd22'/>
	<parameter type-id='3502e3ff'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='nvlist_add_uint64_array' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='nvlist_add_byte_array' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	- <parameter type-id='5d6479ae'/>
	+ <parameter type-id='45b65157'/>
	<parameter type-id='3502e3ff'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='nvlist_add_int64_array' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='nvlist_add_int8_array' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	- <parameter type-id='cb785ebf'/>
	+ <parameter type-id='256d5229'/>
	<parameter type-id='3502e3ff'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='nvlist_add_uint32_array' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='nvlist_add_uint8_array' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	- <parameter type-id='90421557'/>
	+ <parameter type-id='ae3e8ca6'/>
	<parameter type-id='3502e3ff'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='nvlist_add_int32_array' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='nvlist_add_int16_array' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	- <parameter type-id='4aafb922'/>
	+ <parameter type-id='f76f73d0'/>
	<parameter type-id='3502e3ff'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	<function-decl name='nvlist_add_uint16_array' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	<parameter type-id='8a121f49'/>
	<parameter type-id='3502e3ff'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='nvlist_add_int16_array' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='nvlist_add_int32_array' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	- <parameter type-id='f76f73d0'/>
	+ <parameter type-id='4aafb922'/>
	<parameter type-id='3502e3ff'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='nvlist_add_byte_array' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='nvlist_add_uint32_array' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	- <parameter type-id='45b65157'/>
	+ <parameter type-id='90421557'/>
	<parameter type-id='3502e3ff'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='nvlist_add_string' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='nvlist_add_int64_array' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	- <parameter type-id='80f4b756'/>
	+ <parameter type-id='cb785ebf'/>
	+ <parameter type-id='3502e3ff'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='nvlist_add_uint64' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='nvlist_add_uint64_array' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	- <parameter type-id='9c313c2d'/>
	+ <parameter type-id='5d6479ae'/>
	+ <parameter type-id='3502e3ff'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='nvlist_add_int64' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='nvlist_add_string_array' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	- <parameter type-id='9da381c4'/>
	+ <parameter type-id='f319fae0'/>
	+ <parameter type-id='3502e3ff'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='nvlist_add_uint32' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='nvlist_add_nvlist_array' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	- <parameter type-id='8f92235e'/>
	+ <parameter type-id='857bb57e'/>
	+ <parameter type-id='3502e3ff'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='nvlist_add_int32' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='nvlist_remove_all' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	- <parameter type-id='3ff5601b'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='nvlist_add_uint16' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='nvlist_lookup_nvlist' visibility='default' binding='global' size-in-bits='64'>
	<parameter type-id='5ce45b60'/>
	<parameter type-id='80f4b756'/>
	- <parameter type-id='149c6638'/>
	+ <parameter type-id='857bb57e'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='nvlist_add_int16' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='5ce45b60'/>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='23bd8cb5'/>
	+ <function-decl name='lzbe_nvlist_get' mangled-name='lzbe_nvlist_get' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='lzbe_nvlist_get'>
	+ <parameter type-id='80f4b756' name='pool'/>
	+ <parameter type-id='80f4b756' name='key'/>
	+ <parameter type-id='63e171df' name='ptr'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='nvlist_add_byte' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='5ce45b60'/>
	- <parameter type-id='80f4b756'/>
	- <parameter type-id='d8bf0010'/>
	+ <function-decl name='lzbe_nvlist_set' mangled-name='lzbe_nvlist_set' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='lzbe_nvlist_set'>
	+ <parameter type-id='80f4b756' name='pool'/>
	+ <parameter type-id='80f4b756' name='key'/>
	+ <parameter type-id='eaa32e2f' name='ptr'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='nvlist_remove_all' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='5ce45b60'/>
	+ <function-decl name='lzbe_nvlist_free' mangled-name='lzbe_nvlist_free' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='lzbe_nvlist_free'>
	+ <parameter type-id='eaa32e2f' name='ptr'/>
	+ <return type-id='48b5725f'/>
	+ </function-decl>
	+ <function-decl name='lzbe_add_pair' mangled-name='lzbe_add_pair' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='lzbe_add_pair'>
	+ <parameter type-id='eaa32e2f' name='ptr'/>
	+ <parameter type-id='80f4b756' name='key'/>
	+ <parameter type-id='80f4b756' name='type'/>
	+ <parameter type-id='eaa32e2f' name='value'/>
	+ <parameter type-id='b59d7dce' name='size'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='lzbe_remove_pair' mangled-name='lzbe_remove_pair' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='lzbe_remove_pair'>
	+ <parameter type-id='eaa32e2f' name='ptr'/>
	+ <parameter type-id='80f4b756' name='key'/>
	+ <return type-id='95e97e5e'/>
	+ </function-decl>
	+ <function-decl name='strcmp' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='80f4b756'/>
	<parameter type-id='80f4b756'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	</abi-instr>
	- <abi-instr version='1.0' address-size='64' path='lzbe_util.c' language='LANG_C89'>
	+ <abi-instr address-size='64' path='lzbe_util.c' language='LANG_C99'>
	+ <function-decl name='nvlist_print' visibility='default' binding='global' size-in-bits='64'>
	+ <parameter type-id='822cd80b'/>
	+ <parameter type-id='5ce45b60'/>
	+ <return type-id='48b5725f'/>
	+ </function-decl>
	<function-decl name='lzbe_bootenv_print' mangled-name='lzbe_bootenv_print' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='lzbe_bootenv_print'>
	<parameter type-id='80f4b756' name='pool'/>
	<parameter type-id='80f4b756' name='nvlist'/>
	<parameter type-id='822cd80b' name='of'/>
	<return type-id='95e97e5e'/>
	</function-decl>
	- <function-decl name='nvlist_print' visibility='default' binding='global' size-in-bits='64'>
	- <parameter type-id='822cd80b'/>
	- <parameter type-id='5ce45b60'/>
	- <return type-id='48b5725f'/>
	- </function-decl>
	</abi-instr>
	</abi-corpus>
	diff --git a/sys/contrib/openzfs/lib/libzfsbootenv/lzbe_device.c b/sys/contrib/openzfs/lib/libzfsbootenv/lzbe_device.c
	index 2d8833b4fff2..2d9c7b749ef2 100644
	--- a/sys/contrib/openzfs/lib/libzfsbootenv/lzbe_device.c
	+++ b/sys/contrib/openzfs/lib/libzfsbootenv/lzbe_device.c
	@@ -1,163 +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 */
	+ 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 suffix.
	*/
	if (strncmp(device, "zfs:", 4) == 0) {
	fnvlist_add_string(nv, OS_BOOTONCE, device);
	} else {
	if (asprintf(&descriptor, "zfs:%s:", device) > 0) {
	fnvlist_add_string(nv, OS_BOOTONCE, descriptor);
	free(descriptor);
	} else
	rv = ENOMEM;
	}
	}

	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/libzutil/os/freebsd/zutil_import_os.c b/sys/contrib/openzfs/lib/libzutil/os/freebsd/zutil_import_os.c
	index 36c4d90aa4b9..7c48e06f9315 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,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) 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\|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);
	}
	+
	+void
	+update_vdevs_config_dev_sysfs_path(nvlist_t *config)
	+{
	+}
	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 2a6f4ae2a222..13f8bd031612 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,678 @@
	/*
	* 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);
	}

	+/*
	+ * Read the contents of a sysfs file into an allocated buffer and remove the
	+ * last newline.
	+ *
	+ * This is useful for reading sysfs files that return a single string. Return
	+ * an allocated string pointer on success, NULL otherwise. Returned buffer
	+ * must be freed by the user.
	+ */
	+static char *
	+zfs_read_sysfs_file(char *filepath)
	+{
	+ char buf[4096]; /* all sysfs files report 4k size */
	+ char *str = NULL;
	+
	+ FILE *fp = fopen(filepath, "r");
	+ if (fp == NULL) {
	+ return (NULL);
	+ }
	+ if (fgets(buf, sizeof (buf), fp) == buf) {
	+ /* success */
	+
	+ /* Remove the last newline (if any) */
	+ size_t len = strlen(buf);
	+ if (buf[len - 1] == '\n') {
	+ buf[len - 1] = '\0';
	+ }
	+ str = strdup(buf);
	+ }
	+
	+ fclose(fp);
	+
	+ return (str);
	+}
	+
	+/*
	+ * Given a dev name like "nvme0n1", return the full PCI slot sysfs path to
	+ * the drive (in /sys/bus/pci/slots).
	+ *
	+ * For example:
	+ * dev: "nvme0n1"
	+ * returns: "/sys/bus/pci/slots/0"
	+ *
	+ * 'dev' must be an NVMe device.
	+ *
	+ * Returned string must be freed. Returns NULL on error or no sysfs path.
	+ */
	+static char *
	+zfs_get_pci_slots_sys_path(const char *dev_name)
	+{
	+ DIR *dp = NULL;
	+ struct dirent *ep;
	+ char *address1 = NULL;
	+ char *address2 = NULL;
	+ char *path = NULL;
	+ char buf[MAXPATHLEN];
	+ char *tmp;
	+
	+ /* If they preface 'dev' with a path (like "/dev") then strip it off */
	+ tmp = strrchr(dev_name, '/');
	+ if (tmp != NULL)
	+ dev_name = tmp + 1; /* +1 since we want the chr after '/' */
	+
	+ if (strncmp("nvme", dev_name, 4) != 0)
	+ return (NULL);
	+
	+ (void) snprintf(buf, sizeof (buf), "/sys/block/%s/device/address",
	+ dev_name);
	+
	+ address1 = zfs_read_sysfs_file(buf);
	+ if (!address1)
	+ return (NULL);
	+
	+ /*
	+ * /sys/block/nvme0n1/device/address format will
	+ * be "0000:01:00.0" while /sys/bus/pci/slots/0/address will be
	+ * "0000:01:00". Just NULL terminate at the '.' so they match.
	+ */
	+ tmp = strrchr(address1, '.');
	+ if (tmp != NULL)
	+ *tmp = '\0';
	+
	+ dp = opendir("/sys/bus/pci/slots/");
	+ if (dp == NULL) {
	+ free(address1);
	+ return (NULL);
	+ }
	+
	+ /*
	+ * Look through all the /sys/bus/pci/slots/ subdirs
	+ */
	+ while ((ep = readdir(dp))) {
	+ /*
	+ * We only care about directory names that are a single number.
	+ * Sometimes there's other directories like
	+ * "/sys/bus/pci/slots/0-3/" in there - skip those.
	+ */
	+ if (!zfs_isnumber(ep->d_name))
	+ continue;
	+
	+ (void) snprintf(buf, sizeof (buf),
	+ "/sys/bus/pci/slots/%s/address", ep->d_name);
	+
	+ address2 = zfs_read_sysfs_file(buf);
	+ if (!address2)
	+ continue;
	+
	+ if (strcmp(address1, address2) == 0) {
	+ /* Addresses match, we're all done */
	+ free(address2);
	+ if (asprintf(&path, "/sys/bus/pci/slots/%s",
	+ ep->d_name) == -1) {
	+ free(tmp);
	+ continue;
	+ }
	+ break;
	+ }
	+ free(address2);
	+ }
	+
	+ closedir(dp);
	+ free(address1);
	+
	+ return (path);
	+}
	+
	/*
	* 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).
	+ * to it (like /dev/sda). This works for both JBODs and NVMe PCI devices.
	*
	* For example, disk "sda" in enclosure slot 1:
	- * dev: "sda"
	+ * dev_name: "sda"
	* returns: "/sys/class/enclosure/1:0:3:0/Slot 1"
	*
	+ * Or:
	+ *
	+ * dev_name: "nvme0n1"
	+ * returns: "/sys/bus/pci/slots/0"
	+ *
	* 'dev' must be a non-devicemapper device.
	*
	- * Returned string must be freed.
	+ * Returned string must be freed. Returns NULL on error.
	*/
	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)
	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;
	break;
	}

	size = readlink(tmp2, buf, sizeof (buf));

	/* Did readlink fail or crop the link name? */
	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);

	+ if (!path) {
	+ /*
	+ * This particular disk isn't in a JBOD. It could be an NVMe
	+ * drive. If so, look up the NVMe device's path in
	+ * /sys/bus/pci/slots/. Within that directory is a 'attention'
	+ * file which controls the NVMe fault LED.
	+ */
	+ path = zfs_get_pci_slots_sys_path(dev_name);
	+ }
	+
	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;

	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;

	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 && 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.
	*/
	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 \| 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 61c42cf2e3a2..6c406d373a0c 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,911 @@
	/*
	* 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 <libzfs.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 \| O_CLOEXEC);
	if ((fd < 0) && (errno == EINVAL))
	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
	}

	+/*
	+ * Rescan the enclosure sysfs path for turning on enclosure LEDs and store it
	+ * in the nvlist * (if applicable). Like:
	+ * vdev_enc_sysfs_path: '/sys/class/enclosure/11:0:1:0/SLOT 4'
	+ */
	+static void
	+update_vdev_config_dev_sysfs_path(nvlist_t nv, char path)
	+{
	+ char upath, spath;
	+
	+ /* 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);
	+}
	+
	+/*
	+ * This will get called for each leaf vdev.
	+ */
	+static int
	+sysfs_path_pool_vdev_iter_f(void hdl_data, nvlist_t nv, void *data)
	+{
	+ char *path = NULL;
	+ if (nvlist_lookup_string(nv, ZPOOL_CONFIG_PATH, &path) != 0)
	+ return (1);
	+
	+ /* Rescan our enclosure sysfs path for this vdev */
	+ update_vdev_config_dev_sysfs_path(nv, path);
	+ return (0);
	+}
	+
	+/*
	+ * Given an nvlist for our pool (with vdev tree), iterate over all the
	+ * leaf vdevs and update their ZPOOL_CONFIG_VDEV_ENC_SYSFS_PATH.
	+ */
	+void
	+update_vdevs_config_dev_sysfs_path(nvlist_t *config)
	+{
	+ nvlist_t *nvroot = NULL;
	+ verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE,
	+ &nvroot) == 0);
	+ for_each_vdev_in_nvlist(nvroot, sysfs_path_pool_vdev_iter_f, NULL);
	+}
	+
	/*
	* 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);
	+ update_vdev_config_dev_sysfs_path(nv, path);
	} 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 0e59ec8c88c8..d91953813d8c 100644
	--- a/sys/contrib/openzfs/lib/libzutil/zutil_import.c
	+++ b/sys/contrib/openzfs/lib/libzutil/zutil_import.c
	@@ -1,1835 +1,1905 @@
	/*
	* 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;
	switch (aio_error(&aiocbs[l])) {
	case EINVAL:
	break;
	case EINPROGRESS:
	// This shouldn't be possible to
	// encounter, die if we do.
	ASSERT(B_FALSE);
	+ fallthrough;
	case EOPNOTSUPP:
	case ENOSYS:
	do_slow = B_TRUE;
	+ fallthrough;
	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 (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 \| 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 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 \| 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);
	}

	+ update_vdevs_config_dev_sysfs_path(src);
	+
	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);
	}
	+
	+/*
	+ * Internal function for iterating over the vdevs.
	+ *
	+ * For each vdev, func() will be called and will be passed 'zhp' (which is
	+ * typically the zpool_handle_t cast as a void pointer), the vdev's nvlist, and
	+ * a user-defined data pointer).
	+ *
	+ * The return values from all the func() calls will be OR'd together and
	+ * returned.
	+ */
	+int
	+for_each_vdev_cb(void 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);
	+}
	+
	+/*
	+ * Given an ZPOOL_CONFIG_VDEV_TREE nvpair, iterate over all the vdevs, calling
	+ * func() for each one. func() is passed the vdev's nvlist and an optional
	+ * user-defined 'data' pointer.
	+ */
	+int
	+for_each_vdev_in_nvlist(nvlist_t nvroot, pool_vdev_iter_f func, void data)
	+{
	+ return (for_each_vdev_cb(NULL, nvroot, func, data));
	+}
	diff --git a/sys/contrib/openzfs/lib/libzutil/zutil_nicenum.c b/sys/contrib/openzfs/lib/libzutil/zutil_nicenum.c
	index 1a19db0dfebc..4dcac1f855ff 100644
	--- a/sys/contrib/openzfs/lib/libzutil/zutil_nicenum.c
	+++ b/sys/contrib/openzfs/lib/libzutil/zutil_nicenum.c
	@@ -1,175 +1,184 @@
	/*
	* 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>
	+#include <string.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);

	+ /*
	+ * Numbers should not end with a period ("." ".." or "5." are
	+ * not valid)
	+ */
	+ if (str[strlen(str) - 1] == '.') {
	+ 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/man4/zfs.4 b/sys/contrib/openzfs/man/man4/zfs.4
	index 2aed6895754a..20b24d898d84 100644
	--- a/sys/contrib/openzfs/man/man4/zfs.4
	+++ b/sys/contrib/openzfs/man/man4/zfs.4
	@@ -1,2382 +1,2382 @@
	.\"
	.\" 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]
	.\"
	.Dd June 1, 2021
	.Dt ZFS 4
	.Os
	.
	.Sh NAME
	.Nm zfs
	.Nd tuning of the ZFS kernel module
	.
	.Sh DESCRIPTION
	The ZFS module supports these parameters:
	.Bl -tag -width Ds
	.It Sy dbuf_cache_max_bytes Ns = Ns Sy ULONG_MAX Ns B Pq ulong
	Maximum size in bytes of the dbuf cache.
	The target size is determined by the MIN versus
	.No 1/2^ Ns Sy dbuf_cache_shift Pq 1/32nd
	of the target ARC size.
	The behavior of the dbuf cache and its associated settings
	can be observed via the
	.Pa /proc/spl/kstat/zfs/dbufstats
	kstat.
	.
	.It Sy dbuf_metadata_cache_max_bytes Ns = Ns Sy ULONG_MAX Ns B Pq ulong
	Maximum size in bytes of the metadata dbuf cache.
	The target size is determined by the MIN versus
	.No 1/2^ Ns Sy dbuf_metadata_cache_shift Pq 1/64th
	of the target ARC size.
	The behavior of the metadata dbuf cache and its associated settings
	can be observed via the
	.Pa /proc/spl/kstat/zfs/dbufstats
	kstat.
	.
	.It Sy dbuf_cache_hiwater_pct Ns = Ns Sy 10 Ns % Pq uint
	The percentage over
	.Sy dbuf_cache_max_bytes
	when dbufs must be evicted directly.
	.
	.It Sy dbuf_cache_lowater_pct Ns = Ns Sy 10 Ns % Pq uint
	The percentage below
	.Sy dbuf_cache_max_bytes
	when the evict thread stops evicting dbufs.
	.
	.It Sy dbuf_cache_shift Ns = Ns Sy 5 Pq int
	Set the size of the dbuf cache
	.Pq Sy dbuf_cache_max_bytes
	to a log2 fraction of the target ARC size.
	.
	.It Sy dbuf_metadata_cache_shift Ns = Ns Sy 6 Pq int
	Set the size of the dbuf metadata cache
	.Pq Sy dbuf_metadata_cache_max_bytes
	to a log2 fraction of the target ARC size.
	.
	.It Sy dmu_object_alloc_chunk_shift Ns = Ns Sy 7 Po 128 Pc Pq int
	dnode slots allocated in a single operation as a power of 2.
	The default value minimizes lock contention for the bulk operation performed.
	.
	.It Sy dmu_prefetch_max Ns = Ns Sy 134217728 Ns B Po 128MB Pc Pq int
	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.
	.
	.It Sy ignore_hole_birth Pq int
	Alias for
	.Sy send_holes_without_birth_time .
	.
	.It Sy l2arc_feed_again Ns = Ns Sy 1 Ns \| Ns 0 Pq int
	Turbo L2ARC warm-up.
	When the L2ARC is cold the fill interval will be set as fast as possible.
	.
	.It Sy l2arc_feed_min_ms Ns = Ns Sy 200 Pq ulong
	Min feed interval in milliseconds.
	Requires
	.Sy l2arc_feed_again Ns = Ns Ar 1
	and only applicable in related situations.
	.
	.It Sy l2arc_feed_secs Ns = Ns Sy 1 Pq ulong
	Seconds between L2ARC writing.
	.
	.It Sy l2arc_headroom Ns = Ns Sy 2 Pq ulong
	How far through the ARC lists to search for L2ARC cacheable content,
	expressed as a multiplier of
	.Sy l2arc_write_max .
	ARC persistence across reboots can be achieved with persistent L2ARC
	by setting this parameter to
	.Sy 0 ,
	allowing the full length of ARC lists to be searched for cacheable content.
	.
	.It Sy l2arc_headroom_boost Ns = Ns Sy 200 Ns % Pq ulong
	Scales
	.Sy l2arc_headroom
	by this percentage when L2ARC contents are being successfully compressed
	before writing.
	A value of
	.Sy 100
	disables this feature.
	.
	.It Sy l2arc_mfuonly Ns = Ns Sy 0 Ns \| Ns 1 Pq int
	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.
	.Pp
	The default is off,
	meaning both MRU and MFU data and metadata are cached.
	When turning off this feature, some MRU buffers will still be present
	in ARC and eventually cached on L2ARC.
	.No If Sy l2arc_noprefetch Ns = Ns Sy 0 ,
	some prefetched buffers will be cached to L2ARC, and those might later
	transition to MRU, in which case the
	.Sy l2arc_mru_asize No arcstat will not be Sy 0 .
	.Pp
	Regardless of
	.Sy l2arc_noprefetch ,
	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
	.Sy l2arc_mru_asize No arcstat will not be Sy 0 .
	.Pp
	The ARC status of L2ARC buffers when they were first cached in
	L2ARC can be seen in the
	.Sy l2arc_mru_asize , Sy l2arc_mfu_asize , No and Sy l2arc_prefetch_asize
	arcstats when importing the pool or onlining a cache
	device if persistent L2ARC is enabled.
	.Pp
	The
	.Sy evict_l2_eligible_mru
	arcstat does not take into account if this option is enabled as the information
	provided by the
	.Sy evict_l2_eligible_m[rf]u
	arcstats can be used to decide if toggling this option is appropriate
	for the current workload.
	.
	.It Sy l2arc_meta_percent Ns = Ns Sy 33 Ns % Pq int
	Percent of ARC size allowed for L2ARC-only headers.
	Since L2ARC buffers are not evicted on memory pressure,
	too many headers on a system with an irrationally large L2ARC
	can render it slow or unusable.
	This parameter limits L2ARC writes and rebuilds to achieve the target.
	.
	.It Sy l2arc_trim_ahead Ns = Ns Sy 0 Ns % Pq ulong
	Trims ahead of the current write size
	.Pq Sy l2arc_write_max
	on L2ARC devices by this percentage of write size if we have filled the device.
	If set to
	.Sy 100
	we TRIM twice the space required to accommodate upcoming writes.
	A minimum of
	.Sy 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
	.Sy 0
	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.
	.
	.It Sy l2arc_noprefetch Ns = Ns Sy 1 Ns \| Ns 0 Pq int
	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, we do not read the prefetched buffers from L2ARC.
	Unsetting this option 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.
	.Pp
	Use
	.Sy 1
	to disable and
	.Sy 0
	to enable caching/reading prefetches to/from L2ARC.
	.
	.It Sy l2arc_norw Ns = Ns Sy 0 Ns \| Ns 1 Pq int
	No reads during writes.
	.
	.It Sy l2arc_write_boost Ns = Ns Sy 8388608 Ns B Po 8MB Pc Pq ulong
	Cold L2ARC devices will have
	.Sy l2arc_write_max
	increased by this amount while they remain cold.
	.
	.It Sy l2arc_write_max Ns = Ns Sy 8388608 Ns B Po 8MB Pc Pq ulong
	Max write bytes per interval.
	.
	.It Sy l2arc_rebuild_enabled Ns = Ns Sy 1 Ns \| Ns 0 Pq int
	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).
	.
	.It Sy l2arc_rebuild_blocks_min_l2size Ns = Ns Sy 1073741824 Ns B Po 1GB Pc Pq ulong
	Mininum size 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 persistent L2ARC.
	.Pp
	For L2ARC devices less than 1GB, the amount of data
	.Fn 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.
	.
	.It Sy metaslab_aliquot Ns = Ns Sy 524288 Ns B Po 512kB Pc Pq ulong
	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.
	.
	.It Sy metaslab_bias_enabled Ns = Ns Sy 1 Ns \| Ns 0 Pq int
	Enable metaslab group biasing based on their vdevs' over- or under-utilization
	relative to the pool.
	.
	.It Sy metaslab_force_ganging Ns = Ns Sy 16777217 Ns B Ns B Po 16MB + 1B Pc Pq ulong
	Make some blocks above a certain size be gang blocks.
	This option is used by the test suite to facilitate testing.
	.
	.It Sy zfs_history_output_max Ns = Ns Sy 1048576 Ns B Ns B Po 1MB Pc Pq int
	When attempting to log an output nvlist of an ioctl in the on-disk history,
	the output will not be stored if it is larger than this size (in bytes).
	This must be less than
	.Sy DMU_MAX_ACCESS Pq 64MB .
	This applies primarily to
	.Fn zfs_ioc_channel_program Pq cf. Xr zfs-program 8 .
	.
	.It Sy zfs_keep_log_spacemaps_at_export Ns = Ns Sy 0 Ns \| Ns 1 Pq int
	Prevent log spacemaps from being destroyed during pool exports and destroys.
	.
	.It Sy zfs_metaslab_segment_weight_enabled Ns = Ns Sy 1 Ns \| Ns 0 Pq int
	Enable/disable segment-based metaslab selection.
	.
	.It Sy zfs_metaslab_switch_threshold Ns = Ns Sy 2 Pq int
	When using segment-based metaslab selection, continue allocating
	from the active metaslab until this option's
	worth of buckets have been exhausted.
	.
	.It Sy metaslab_debug_load Ns = Ns Sy 0 Ns \| Ns 1 Pq int
	Load all metaslabs during pool import.
	.
	.It Sy metaslab_debug_unload Ns = Ns Sy 0 Ns \| Ns 1 Pq int
	Prevent metaslabs from being unloaded.
	.
	.It Sy metaslab_fragmentation_factor_enabled Ns = Ns Sy 1 Ns \| Ns 0 Pq int
	Enable use of the fragmentation metric in computing metaslab weights.
	.
	.It Sy metaslab_df_max_search Ns = Ns Sy 16777216 Ns B Po 16MB Pc Pq int
	Maximum distance to search forward from the last offset.
	Without this limit, fragmented pools can see
	.Em >100`000
	iterations and
	.Fn metaslab_block_picker
	becomes the performance limiting factor on high-performance storage.
	.Pp
	With the default setting of
	.Sy 16MB ,
	we typically see less than
	.Em 500
	iterations, even with very fragmented
	.Sy ashift Ns = Ns Sy 9
	pools.
	The maximum number of iterations possible is
	.Sy metaslab_df_max_search / 2^(ashift+1) .
	With the default setting of
	.Sy 16MB
	this is
	.Em 16*1024 Pq with Sy ashift Ns = Ns Sy 9
	or
	.Em 2*1024 Pq with Sy ashift Ns = Ns Sy 12 .
	.
	.It Sy metaslab_df_use_largest_segment Ns = Ns Sy 0 Ns \| Ns 1 Pq int
	If not searching forward (due to
	.Sy metaslab_df_max_search , metaslab_df_free_pct ,
	.No or Sy metaslab_df_alloc_threshold ) ,
	this tunable controls which segment is used.
	If set, we will use the largest free segment.
	If unset, we will use a segment of at least the requested size.
	.
	.It Sy zfs_metaslab_max_size_cache_sec Ns = Ns Sy 3600 Ns s Po 1h Pc Pq ulong
	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.
	.
	.It Sy zfs_metaslab_mem_limit Ns = Ns Sy 25 Ns % Pq int
	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.
	.
	.It Sy zfs_metaslab_try_hard_before_gang Ns = Ns Sy 0 Ns \| Ns 1 Pq int
	.Bl -item -compact
	.It
	If unset, we will first try normal allocation.
	.It
	If that fails then we will do a gang allocation.
	.It
	If that fails then we will do a "try hard" gang allocation.
	.It
	If that fails then we will have a multi-layer gang block.
	.El
	.Pp
	.Bl -item -compact
	.It
	If set, we will first try normal allocation.
	.It
	If that fails then we will do a "try hard" allocation.
	.It
	If that fails we will do a gang allocation.
	.It
	If that fails we will do a "try hard" gang allocation.
	.It
	If that fails then we will have a multi-layer gang block.
	.El
	.
	.It Sy zfs_metaslab_find_max_tries Ns = Ns Sy 100 Pq int
	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 metaslabs).
	.
	.It Sy zfs_vdev_default_ms_count Ns = Ns Sy 200 Pq int
	When a vdev is added, target this number of metaslabs per top-level vdev.
	.
	.It Sy zfs_vdev_default_ms_shift Ns = Ns Sy 29 Po 512MB Pc Pq int
	Default limit for metaslab size.
	.
	.It Sy zfs_vdev_max_auto_ashift Ns = Ns Sy ASHIFT_MAX Po 16 Pc Pq ulong
	Maximum ashift used when optimizing for logical -> physical sector size on new
	top-level vdevs.
	.
	.It Sy zfs_vdev_min_auto_ashift Ns = Ns Sy ASHIFT_MIN Po 9 Pc Pq ulong
	Minimum ashift used when creating new top-level vdevs.
	.
	.It Sy zfs_vdev_min_ms_count Ns = Ns Sy 16 Pq int
	Minimum number of metaslabs to create in a top-level vdev.
	.
	.It Sy vdev_validate_skip Ns = Ns Sy 0 Ns \| Ns 1 Pq int
	Skip label validation steps during pool import.
	Changing is not recommended unless you know what you're doing
	and are recovering a damaged label.
	.
	.It Sy zfs_vdev_ms_count_limit Ns = Ns Sy 131072 Po 128k Pc Pq int
	Practical upper limit of total metaslabs per top-level vdev.
	.
	.It Sy metaslab_preload_enabled Ns = Ns Sy 1 Ns \| Ns 0 Pq int
	Enable metaslab group preloading.
	.
	.It Sy metaslab_lba_weighting_enabled Ns = Ns Sy 1 Ns \| Ns 0 Pq int
	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.
	.
	.It Sy metaslab_unload_delay Ns = Ns Sy 32 Pq int
	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
	.Sy metaslab_unload_delay_ms
	milliseconds must pass before unloading will occur.
	.
	.It Sy metaslab_unload_delay_ms Ns = Ns Sy 600000 Ns ms Po 10min Pc Pq int
	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
	.Sy metaslab_unload_delay
	TXGs must pass before unloading will occur.
	.
	.It Sy reference_history Ns = Ns Sy 3 Pq int
	Maximum reference holders being tracked when reference_tracking_enable is active.
	.
	.It Sy reference_tracking_enable Ns = Ns Sy 0 Ns \| Ns 1 Pq int
	Track reference holders to
	.Sy refcount_t
	objects (debug builds only).
	.
	.It Sy send_holes_without_birth_time Ns = Ns Sy 1 Ns \| Ns 0 Pq int
	When set, the
	.Sy hole_birth
	optimization will not be used, and all holes will always be sent during a
	.Nm zfs Cm send .
	This is useful if you suspect your datasets are affected by a bug in
	.Sy hole_birth .
	.
	.It Sy spa_config_path Ns = Ns Pa /etc/zfs/zpool.cache Pq charp
	SPA config file.
	.
	.It Sy spa_asize_inflation Ns = Ns Sy 24 Pq int
	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.
	.
	.It Sy spa_load_print_vdev_tree Ns = Ns Sy 0 Ns \| Ns 1 Pq int
	Whether to print the vdev tree in the debugging message buffer during pool import.
	.
	.It Sy spa_load_verify_data Ns = Ns Sy 1 Ns \| Ns 0 Pq int
	Whether to traverse data blocks during an "extreme rewind"
	.Pq Fl X
	import.
	.Pp
	An extreme rewind import normally performs a full traversal of all
	blocks in the pool for verification.
	If this parameter is unset, 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.
	.
	.It Sy spa_load_verify_metadata Ns = Ns Sy 1 Ns \| Ns 0 Pq int
	Whether to traverse blocks during an "extreme rewind"
	.Pq Fl X
	pool import.
	.Pp
	An extreme rewind import normally performs a full traversal of all
	blocks in the pool for verification.
	If this parameter is unset, the traversal is not performed.
	It can be toggled once the import has started to stop or start the traversal.
	.
	.It Sy spa_load_verify_shift Ns = Ns Sy 4 Po 1/16th Pc Pq int
	Sets the maximum number of bytes to consume during pool import to the log2
	fraction of the target ARC size.
	.
	.It Sy spa_slop_shift Ns = Ns Sy 5 Po 1/32nd Pc Pq int
	Normally, we don't allow the last
	.Sy 3.2% Pq Sy 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
	.Sy ENOSPC .
	.
	.It Sy vdev_removal_max_span Ns = Ns Sy 32768 Ns B Po 32kB Pc Pq int
	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.
	.Pp
	The default value here was chosen to align with
	.Sy zfs_vdev_read_gap_limit ,
	which is a similar concept when doing
	regular reads (but there's no reason it has to be the same).
	.
	.It Sy vdev_file_logical_ashift Ns = Ns Sy 9 Po 512B Pc Pq ulong
	Logical ashift for file-based devices.
	.
	.It Sy vdev_file_physical_ashift Ns = Ns Sy 9 Po 512B Pc Pq ulong
	Physical ashift for file-based devices.
	.
	.It Sy zap_iterate_prefetch Ns = Ns Sy 1 Ns \| Ns 0 Pq int
	If set, when we start iterating over a ZAP object,
	prefetch the entire object (all leaf blocks).
	However, this is limited by
	.Sy dmu_prefetch_max .
	.
	.It Sy zfetch_array_rd_sz Ns = Ns Sy 1048576 Ns B Po 1MB Pc Pq ulong
	If prefetching is enabled, disable prefetching for reads larger than this size.
	.
	.It Sy zfetch_max_distance Ns = Ns Sy 8388608 Ns B Po 8MB Pc Pq uint
	Max bytes to prefetch per stream.
	.
	.It Sy zfetch_max_idistance Ns = Ns Sy 67108864 Ns B Po 64MB Pc Pq uint
	Max bytes to prefetch indirects for per stream.
	.
	.It Sy zfetch_max_streams Ns = Ns Sy 8 Pq uint
	Max number of streams per zfetch (prefetch streams per file).
	.
	.It Sy zfetch_min_sec_reap Ns = Ns Sy 2 Pq uint
	Min time before an active prefetch stream can be reclaimed
	.
	.It Sy zfs_abd_scatter_enabled Ns = Ns Sy 1 Ns \| Ns 0 Pq int
	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.
	.
	.It Sy zfs_abd_scatter_max_order Ns = Ns Sy MAX_ORDER-1 Pq uint
	Maximum number of consecutive memory pages allocated in a single block for
	scatter/gather lists.
	.Pp
	The value of
	.Sy MAX_ORDER
	depends on kernel configuration.
	.
	.It Sy zfs_abd_scatter_min_size Ns = Ns Sy 1536 Ns B Po 1.5kB Pc Pq uint
	This is the minimum allocation size that will use scatter (page-based) ABDs.
	Smaller allocations will use linear ABDs.
	.
	.It Sy zfs_arc_dnode_limit Ns = Ns Sy 0 Ns B Pq ulong
	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
	.Sy 0 ,
	which indicates that a percent which is based on
	.Sy zfs_arc_dnode_limit_percent
	of the ARC meta buffers that may be used for dnodes.
	.Pp
	Also see
	.Sy zfs_arc_meta_prune
	which serves a similar purpose but is used
	when the amount of metadata in the ARC exceeds
	.Sy zfs_arc_meta_limit
	rather than in response to overall demand for non-metadata.
	.
	.It Sy zfs_arc_dnode_limit_percent Ns = Ns Sy 10 Ns % Pq ulong
	Percentage that can be consumed by dnodes of ARC meta buffers.
	.Pp
	See also
	.Sy zfs_arc_dnode_limit ,
	which serves a similar purpose but has a higher priority if nonzero.
	.
	.It Sy zfs_arc_dnode_reduce_percent Ns = Ns Sy 10 Ns % Pq ulong
	Percentage of ARC dnodes to try to scan in response to demand for non-metadata
	when the number of bytes consumed by dnodes exceeds
	.Sy zfs_arc_dnode_limit .
	.
	.It Sy zfs_arc_average_blocksize Ns = Ns Sy 8192 Ns B Po 8kB Pc Pq int
	The ARC's buffer hash table is sized based on the assumption of an average
	block size of this value.
	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.
	.
	.It Sy zfs_arc_eviction_pct Ns = Ns Sy 200 Ns % Pq int
	When
	.Fn arc_is_overflowing ,
	.Fn arc_get_data_impl
	waits for this percent of the requested amount of data to be evicted.
	For example, by default, for every
	.Em 2kB
	that's evicted,
	.Em 1kB
	of it may be "reused" by a new allocation.
	Since this is above
	.Sy 100 Ns % ,
	it ensures that progress is made towards getting
	.Sy arc_size No under Sy arc_c .
	Since this is finite, it ensures that allocations can still happen,
	even during the potentially long time that
	.Sy arc_size No is more than Sy arc_c .
	.
	.It Sy zfs_arc_evict_batch_limit Ns = Ns Sy 10 Pq int
	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.
	.
	.It Sy zfs_arc_grow_retry Ns = Ns Sy 0 Ns s Pq int
	If set to a non zero value, it will replace the
	.Sy arc_grow_retry
	value with this value.
	The
	.Sy arc_grow_retry
	.No value Pq default Sy 5 Ns s
	is the number of seconds the ARC will wait before
	trying to resume growth after a memory pressure event.
	.
	.It Sy zfs_arc_lotsfree_percent Ns = Ns Sy 10 Ns % Pq int
	Throttle I/O when free system memory drops below this percentage of total
	system memory.
	Setting this value to
	.Sy 0
	will disable the throttle.
	.
	.It Sy zfs_arc_max Ns = Ns Sy 0 Ns B Pq ulong
	Max size of ARC in bytes.
	If
	.Sy 0 ,
	then the max size of ARC is determined by the amount of system memory installed.
	Under Linux, half of system memory will be used as the limit.
	Under
	.Fx ,
	the larger of
	.Sy all_system_memory - 1GB No and Sy 5/8 * all_system_memory
	will be used as the limit.
	This value must be at least
	.Sy 67108864 Ns B Pq 64MB .
	.Pp
	This value can be changed dynamically, with some caveats.
	It cannot be set back to
	.Sy 0
	while running, and reducing it below the current ARC size will not cause
	the ARC to shrink without memory pressure to induce shrinking.
	.
	.It Sy zfs_arc_meta_adjust_restarts Ns = Ns Sy 4096 Pq ulong
	The number of restart passes to make while scanning the ARC attempting
	the free buffers in order to stay below the
	.Sy fs_arc_meta_limit .
	This value should not need to be tuned but is available to facilitate
	performance analysis.
	.
	.It Sy zfs_arc_meta_limit Ns = Ns Sy 0 Ns B Pq ulong
	The maximum allowed size in bytes that metadata buffers are allowed to
	consume in the ARC.
	When this limit is reached, metadata buffers will be reclaimed,
	even if the overall
	.Sy arc_c_max
	has not been reached.
	It defaults to
	.Sy 0 ,
	which indicates that a percentage based on
	.Sy zfs_arc_meta_limit_percent
	of the ARC may be used for metadata.
	.Pp
	This value my be changed dynamically, except that must be set to an explicit value
	.Pq cannot be set back to Sy 0 .
	.
	.It Sy zfs_arc_meta_limit_percent Ns = Ns Sy 75 Ns % Pq ulong
	Percentage of ARC buffers that can be used for metadata.
	.Pp
	See also
	.Sy zfs_arc_meta_limit ,
	which serves a similar purpose but has a higher priority if nonzero.
	.
	.It Sy zfs_arc_meta_min Ns = Ns Sy 0 Ns B Pq ulong
	The minimum allowed size in bytes that metadata buffers may consume in
	the ARC.
	.
	.It Sy zfs_arc_meta_prune Ns = Ns Sy 10000 Pq int
	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
	.Sy zfs_arc_meta_limit
	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
	.Sy 0
	will disable pruning the inode and dentry caches.
	.
	.It Sy zfs_arc_meta_strategy Ns = Ns Sy 1 Ns \| Ns 0 Pq int
	Define the strategy for ARC metadata buffer eviction (meta reclaim strategy):
	.Bl -tag -compact -offset 4n -width "0 (META_ONLY)"
	.It Sy 0 Pq META_ONLY
	evict only the ARC metadata buffers
	.It Sy 1 Pq BALANCED
	additional data buffers may be evicted if required
	to evict the required number of metadata buffers.
	.El
	.
	.It Sy zfs_arc_min Ns = Ns Sy 0 Ns B Pq ulong
	Min size of ARC in bytes.
	.No If set to Sy 0 , arc_c_min
	will default to consuming the larger of
	.Sy 32MB No or Sy all_system_memory/32 .
	.
	.It Sy zfs_arc_min_prefetch_ms Ns = Ns Sy 0 Ns ms Ns Po Ns ≡ Ns 1s Pc Pq int
	Minimum time prefetched blocks are locked in the ARC.
	.
	.It Sy zfs_arc_min_prescient_prefetch_ms Ns = Ns Sy 0 Ns ms Ns Po Ns ≡ Ns 6s Pc Pq int
	Minimum time "prescient prefetched" blocks are locked in the ARC.
	These blocks are meant to be prefetched fairly aggressively ahead of
	the code that may use them.
	.
	.It Sy zfs_max_missing_tvds Ns = Ns Sy 0 Pq int
	Number of missing top-level vdevs which will be allowed during
	pool import (only in read-only mode).
	.
	.It Sy zfs_max_nvlist_src_size Ns = Sy 0 Pq ulong
	Maximum size in bytes allowed to be passed as
	.Sy zc_nvlist_src_size
	for ioctls on
	.Pa /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
	.Sy EINVAL
	and a description of the error is sent to the
	.Pa zfs-dbgmsg
	log.
	This parameter should not need to be touched under normal circumstances.
	If
	.Sy 0 ,
	equivalent to a quarter of the user-wired memory limit under
	.Fx
	and to
	.Sy 134217728 Ns B Pq 128MB
	under Linux.
	.
	.It Sy zfs_multilist_num_sublists Ns = Ns Sy 0 Pq int
	To allow more fine-grained locking, each ARC state contains a series
	of lists for both data and metadata 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.
	.Pp
	If
	.Sy 0 ,
	equivalent to the greater of the number of online CPUs and
	.Sy 4 .
	.
	.It Sy zfs_arc_overflow_shift Ns = Ns Sy 8 Pq int
	The ARC size is considered to be overflowing if it exceeds the current
	ARC target size
	.Pq Sy arc_c
	by thresholds determined by this parameter.
	Exceeding by
	.Sy ( arc_c >> zfs_arc_overflow_shift ) * 0.5
	starts ARC reclamation process.
	If that appears insufficient, exceeding by
	.Sy ( arc_c >> zfs_arc_overflow_shift ) * 1.5
	blocks new buffer allocation until the reclaim thread catches up.
	Started reclamation process continues till ARC size returns below the
	target size.
	.Pp
	The default value of
	.Sy 8
	causes the ARC to start reclamation if it exceeds the target size by
	.Em 0.2%
	of the target size, and block allocations by
	.Em 0.6% .
	.
	.It Sy zfs_arc_p_min_shift Ns = Ns Sy 0 Pq int
	If nonzero, this will update
	.Sy arc_p_min_shift Pq default Sy 4
	with the new value.
	.Sy arc_p_min_shift No is used as a shift of Sy arc_c
	when calculating the minumum
	.Sy arc_p No size.
	.
	.It Sy zfs_arc_p_dampener_disable Ns = Ns Sy 1 Ns \| Ns 0 Pq int
	Disable
	.Sy arc_p
	adapt dampener, which reduces the maximum single adjustment to
	.Sy arc_p .
	.
	.It Sy zfs_arc_shrink_shift Ns = Ns Sy 0 Pq int
	If nonzero, this will update
	.Sy arc_shrink_shift Pq default Sy 7
	with the new value.
	.
	.It Sy zfs_arc_pc_percent Ns = Ns Sy 0 Ns % Po off Pc Pq uint
	Percent of pagecache to reclaim ARC to.
	.Pp
	This tunable allows the 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 the ARC to be reclaimed down to
	.Sy zfs_arc_min
	if necessary.
	This value is specified as percent of pagecache size (as measured by
	.Sy NR_FILE_PAGES ) ,
	where that percent may exceed
	.Sy 100 .
	This
	only operates during memory pressure/reclaim.
	.
	.It Sy zfs_arc_shrinker_limit Ns = Ns Sy 10000 Pq int
	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 four times this for one allocation attempt.
	.Pp
	The default limit of
	.Sy 10000 Pq in practice, Em 160MB No per allocation attempt with 4kB 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.
	.Pp
	The parameter can be set to 0 (zero) to disable the limit,
	and only applies on Linux.
	.
	.It Sy zfs_arc_sys_free Ns = Ns Sy 0 Ns B Pq ulong
	The target number of bytes the ARC should leave as free memory on the system.
	If zero, equivalent to the bigger of
	.Sy 512kB No and Sy all_system_memory/64 .
	.
	.It Sy zfs_autoimport_disable Ns = Ns Sy 1 Ns \| Ns 0 Pq int
	Disable pool import at module load by ignoring the cache file
	.Pq Sy spa_config_path .
	.
	.It Sy zfs_checksum_events_per_second Ns = Ns Sy 20 Ns /s Pq uint
	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 seconds)
	or else the daemon may not trigger any action.
	.
	.It Sy zfs_commit_timeout_pct Ns = Ns Sy 5 Ns % Pq int
	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).
	.
	.It Sy zfs_condense_indirect_commit_entry_delay_ms Ns = Ns Sy 0 Ns ms Pq int
	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.
	.
	.It Sy zfs_condense_indirect_obsolete_pct Ns = Ns Sy 25 Ns % Pq int
	Minimum percent of obsolete bytes in vdev mapping required to attempt to condense
	.Pq see Sy zfs_condense_indirect_vdevs_enable .
	Intended for use with the test suite
	to facilitate triggering condensing as needed.
	.
	.It Sy zfs_condense_indirect_vdevs_enable Ns = Ns Sy 1 Ns \| Ns 0 Pq int
	Enable condensing indirect vdev mappings.
	When set, attempt to condense indirect vdev mappings
	if the mapping uses more than
	.Sy zfs_condense_min_mapping_bytes
	bytes of memory and if the obsolete space map object uses more than
	.Sy zfs_condense_max_obsolete_bytes
	bytes on-disk.
	The condensing process is an attempt to save memory by removing obsolete mappings.
	.
	.It Sy zfs_condense_max_obsolete_bytes Ns = Ns Sy 1073741824 Ns B Po 1GB Pc Pq ulong
	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
	.Pq see Sy zfs_condense_indirect_vdevs_enable .
	.
	.It Sy zfs_condense_min_mapping_bytes Ns = Ns Sy 131072 Ns B Po 128kB Pc Pq ulong
	Minimum size vdev mapping to attempt to condense
	.Pq see Sy zfs_condense_indirect_vdevs_enable .
	.
	.It Sy zfs_dbgmsg_enable Ns = Ns Sy 1 Ns \| Ns 0 Pq int
	Internally ZFS keeps a small log to facilitate debugging.
	The log is enabled by default, and can be disabled by unsetting this option.
	The contents of the log can be accessed by reading
	.Pa /proc/spl/kstat/zfs/dbgmsg .
	Writing
	.Sy 0
	to the file clears the log.
	.Pp
	This setting does not influence debug prints due to
	.Sy zfs_flags .
	.
	.It Sy zfs_dbgmsg_maxsize Ns = Ns Sy 4194304 Ns B Po 4MB Pc Pq int
	Maximum size of the internal ZFS debug log.
	.
	.It Sy zfs_dbuf_state_index Ns = Ns Sy 0 Pq int
	Historically used for controlling what reporting was available under
	.Pa /proc/spl/kstat/zfs .
	No effect.
	.
	.It Sy zfs_deadman_enabled Ns = Ns Sy 1 Ns \| Ns 0 Pq int
	When a pool sync operation takes longer than
	.Sy zfs_deadman_synctime_ms ,
	or when an individual I/O operation takes longer than
	.Sy zfs_deadman_ziotime_ms ,
	then the operation is considered to be "hung".
	If
	.Sy zfs_deadman_enabled
	is set, then the deadman behavior is invoked as described by
	.Sy zfs_deadman_failmode .
	By default, the deadman is enabled and set to
	.Sy wait
	which results in "hung" I/Os only being logged.
	The deadman is automatically disabled when a pool gets suspended.
	.
	.It Sy zfs_deadman_failmode Ns = Ns Sy wait Pq charp
	Controls the failure behavior when the deadman detects a "hung" I/O operation.
	Valid values are:
	.Bl -tag -compact -offset 4n -width "continue"
	.It Sy wait
	Wait for a "hung" operation to complete.
	For each "hung" operation a "deadman" event will be posted
	describing that operation.
	.It Sy continue
	Attempt to recover from a "hung" operation by re-dispatching it
	to the I/O pipeline if possible.
	.It Sy panic
	Panic the system.
	This can be used to facilitate automatic fail-over
	to a properly configured fail-over partner.
	.El
	.
	.It Sy zfs_deadman_checktime_ms Ns = Ns Sy 60000 Ns ms Po 1min Pc Pq int
	Check time in milliseconds.
	This defines the frequency at which we check for hung I/O requests
	and potentially invoke the
	.Sy zfs_deadman_failmode
	behavior.
	.
	.It Sy zfs_deadman_synctime_ms Ns = Ns Sy 600000 Ns ms Po 10min Pc Pq ulong
	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
	.Sy zfs_deadman_checktime_ms
	milliseconds until the pool sync completes.
	.
	.It Sy zfs_deadman_ziotime_ms Ns = Ns Sy 300000 Ns ms Po 5min Pc Pq ulong
	Interval in milliseconds after which the deadman is triggered and an
	individual I/O operation is considered to be "hung".
	As long as the operation remains "hung",
	the deadman will be invoked every
	.Sy zfs_deadman_checktime_ms
	milliseconds until the operation completes.
	.
	.It Sy zfs_dedup_prefetch Ns = Ns Sy 0 Ns \| Ns 1 Pq int
	Enable prefetching dedup-ed blocks which are going to be freed.
	.
	.It Sy zfs_delay_min_dirty_percent Ns = Ns Sy 60 Ns % Pq int
	Start to delay each transaction once there is this amount of dirty data,
	expressed as a percentage of
	.Sy zfs_dirty_data_max .
	This value should be at least
	.Sy zfs_vdev_async_write_active_max_dirty_percent .
	.No See Sx ZFS TRANSACTION DELAY .
	.
	.It Sy zfs_delay_scale Ns = Ns Sy 500000 Pq int
	This controls how quickly the transaction delay approaches infinity.
	Larger values cause longer delays for a given amount of dirty data.
	.Pp
	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 ten times and a tenth of this number.
	.No See Sx ZFS TRANSACTION DELAY .
	.Pp
	.Sy zfs_delay_scale * zfs_dirty_data_max Em must be smaller than Sy 2^64 .
	.
	.It Sy zfs_disable_ivset_guid_check Ns = Ns Sy 0 Ns \| Ns 1 Pq int
	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.
	.
	.It Sy zfs_key_max_salt_uses Ns = Ns Sy 400000000 Po 4*10^8 Pc Pq ulong
	Maximum number of uses of a single salt value before generating a new one for
	encrypted datasets.
	The default value is also the maximum.
	.
	.It Sy zfs_object_mutex_size Ns = Ns Sy 64 Pq uint
	Size of the znode hashtable used for holds.
	.Pp
	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.
	.
	.It Sy zfs_slow_io_events_per_second Ns = Ns Sy 20 Ns /s Pq int
	Rate limit delay and deadman zevents (which report slow I/Os) to this many per
	second.
	.
	.It Sy zfs_unflushed_max_mem_amt Ns = Ns Sy 1073741824 Ns B Po 1GB Pc Pq ulong
	Upper-bound limit for unflushed metadata changes to be held by the
	log spacemap in memory, in bytes.
	.
	.It Sy zfs_unflushed_max_mem_ppm Ns = Ns Sy 1000 Ns ppm Po 0.1% Pc Pq ulong
	Part of overall system memory that ZFS allows to be used
	for unflushed metadata changes by the log spacemap, in millionths.
	.
	.It Sy zfs_unflushed_log_block_max Ns = Ns Sy 262144 Po 256k Pc Pq ulong
	Describes the maximum number of log spacemap blocks allowed for each pool.
	The default value means that the space in all the log spacemaps
	can add up to no more than
	.Sy 262144
	blocks (which means
	.Em 32GB
	of logical space before compression and ditto blocks,
	assuming that blocksize is
	.Em 128kB ) .
	.Pp
	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.
	.Pp
	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.
	.
	.It Sy zfs_unflushed_log_block_min Ns = Ns Sy 1000 Pq ulong
	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.
	.
	.It Sy zfs_unflushed_log_block_pct Ns = Ns Sy 400 Ns % Pq ulong
	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.
	.
	.It Sy zfs_unlink_suspend_progress Ns = Ns Sy 0 Ns \| Ns 1 Pq uint
	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.
	.
	.It Sy zfs_delete_blocks Ns = Ns Sy 20480 Pq ulong
	This is the used to define a large file for the purposes of deletion.
	Files containing more than
	.Sy zfs_delete_blocks
	will be deleted asynchronously, while smaller files are deleted synchronously.
	Decreasing this value will reduce the time spent in an
	.Xr unlink 2
	system call, at the expense of a longer delay before the freed space is available.
	.
	.It Sy zfs_dirty_data_max Ns = Pq int
	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
	.Sy zfs_dirty_data_max_percent .
	.No See Sx ZFS TRANSACTION DELAY .
	.Pp
	Defaults to
	.Sy physical_ram/10 ,
	capped at
	.Sy zfs_dirty_data_max_max .
	.
	.It Sy zfs_dirty_data_max_max Ns = Pq int
	Maximum allowable value of
	.Sy zfs_dirty_data_max ,
	expressed in bytes.
	This limit is only enforced at module load time, and will be ignored if
	.Sy zfs_dirty_data_max
	is later changed.
	This parameter takes precedence over
	.Sy zfs_dirty_data_max_max_percent .
	.No See Sx ZFS TRANSACTION DELAY .
	.Pp
	Defaults to
	.Sy physical_ram/4 ,
	.
	.It Sy zfs_dirty_data_max_max_percent Ns = Ns Sy 25 Ns % Pq int
	Maximum allowable value of
	.Sy zfs_dirty_data_max ,
	expressed as a percentage of physical RAM.
	This limit is only enforced at module load time, and will be ignored if
	.Sy zfs_dirty_data_max
	is later changed.
	The parameter
	.Sy zfs_dirty_data_max_max
	takes precedence over this one.
	.No See Sx ZFS TRANSACTION DELAY .
	.
	.It Sy zfs_dirty_data_max_percent Ns = Ns Sy 10 Ns % Pq int
	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
	.Sy zfs_dirty_data_max
	takes precedence over this one.
	.No See Sx ZFS TRANSACTION DELAY .
	.Pp
	Subject to
	.Sy zfs_dirty_data_max_max .
	.
	.It Sy zfs_dirty_data_sync_percent Ns = Ns Sy 20 Ns % Pq int
	Start syncing out a transaction group if there's at least this much dirty data
	.Pq as a percentage of Sy zfs_dirty_data_max .
	This should be less than
	.Sy zfs_vdev_async_write_active_min_dirty_percent .
	.
	.It Sy zfs_fallocate_reserve_percent Ns = Ns Sy 110 Ns % Pq uint
	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,
	.Xr fallocate 2
	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
	.Sy zfs_fallocate_reserve_percent
	to allow additional space for indirect blocks and other internal metadata.
	Setting this to
	.Sy 0
	disables support for
	.Xr fallocate 2
	and causes it to return
	.Sy EOPNOTSUPP .
	.
	.It Sy zfs_fletcher_4_impl Ns = Ns Sy fastest Pq string
	Select a fletcher 4 implementation.
	.Pp
	Supported selectors are:
	.Sy fastest , scalar , sse2 , ssse3 , avx2 , avx512f , avx512bw ,
	.No and Sy aarch64_neon .
	All except
	.Sy fastest No and Sy scalar
	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
	.Sy fastest
	will be chosen using a micro benchmark.
	Selecting
	.Sy scalar
	results in the original CPU-based calculation being used.
	Selecting any option other than
	.Sy fastest No or Sy scalar
	results in vector instructions
	from the respective CPU instruction set being used.
	.
	.It Sy zfs_free_bpobj_enabled Ns = Ns Sy 1 Ns \| Ns 0 Pq int
	Enable/disable the processing of the free_bpobj object.
	.
	.It Sy zfs_async_block_max_blocks Ns = Ns Sy ULONG_MAX Po unlimited Pc Pq ulong
	Maximum number of blocks freed in a single TXG.
	.
	.It Sy zfs_max_async_dedup_frees Ns = Ns Sy 100000 Po 10^5 Pc Pq ulong
	Maximum number of dedup blocks freed in a single TXG.
	.
	.It Sy zfs_override_estimate_recordsize Ns = Ns Sy 0 Pq ulong
	If nonzer, override record size calculation for
	.Nm zfs Cm send
	estimates.
	.
	.It Sy zfs_vdev_async_read_max_active Ns = Ns Sy 3 Pq int
	Maximum asynchronous read I/O operations active to each device.
	.No See Sx ZFS I/O SCHEDULER .
	.
	.It Sy zfs_vdev_async_read_min_active Ns = Ns Sy 1 Pq int
	Minimum asynchronous read I/O operation active to each device.
	.No See Sx ZFS I/O SCHEDULER .
	.
	.It Sy zfs_vdev_async_write_active_max_dirty_percent Ns = Ns Sy 60 Ns % Pq int
	When the pool has more than this much dirty data, use
	.Sy zfs_vdev_async_write_max_active
	to limit active async writes.
	If the dirty data is between the minimum and maximum,
	the active I/O limit is linearly interpolated.
	.No See Sx ZFS I/O SCHEDULER .
	.
	.It Sy zfs_vdev_async_write_active_min_dirty_percent Ns = Ns Sy 30 Ns % Pq int
	When the pool has less than this much dirty data, use
	.Sy zfs_vdev_async_write_min_active
	to limit active async writes.
	If the dirty data is between the minimum and maximum,
	the active I/O limit is linearly
	interpolated.
	.No See Sx ZFS I/O SCHEDULER .
	.
	.It Sy zfs_vdev_async_write_max_active Ns = Ns Sy 30 Pq int
	Maximum asynchronous write I/O operations active to each device.
	.No See Sx ZFS I/O SCHEDULER .
	.
	.It Sy zfs_vdev_async_write_min_active Ns = Ns Sy 2 Pq int
	Minimum asynchronous write I/O operations active to each device.
	.No See Sx ZFS I/O SCHEDULER .
	.Pp
	Lower values are associated with better latency on rotational media but poorer
	resilver performance.
	The default value of
	.Sy 2
	was chosen as a compromise.
	A value of
	.Sy 3
	has been shown to improve resilver performance further at a cost of
	further increasing latency.
	.
	.It Sy zfs_vdev_initializing_max_active Ns = Ns Sy 1 Pq int
	Maximum initializing I/O operations active to each device.
	.No See Sx ZFS I/O SCHEDULER .
	.
	.It Sy zfs_vdev_initializing_min_active Ns = Ns Sy 1 Pq int
	Minimum initializing I/O operations active to each device.
	.No See Sx ZFS I/O SCHEDULER .
	.
	.It Sy zfs_vdev_max_active Ns = Ns Sy 1000 Pq int
	The maximum number of I/O operations active to each device.
	Ideally, this will be at least the sum of each queue's
	.Sy max_active .
	.No See Sx ZFS I/O SCHEDULER .
	.
	.It Sy zfs_vdev_rebuild_max_active Ns = Ns Sy 3 Pq int
	Maximum sequential resilver I/O operations active to each device.
	.No See Sx ZFS I/O SCHEDULER .
	.
	.It Sy zfs_vdev_rebuild_min_active Ns = Ns Sy 1 Pq int
	Minimum sequential resilver I/O operations active to each device.
	.No See Sx ZFS I/O SCHEDULER .
	.
	.It Sy zfs_vdev_removal_max_active Ns = Ns Sy 2 Pq int
	Maximum removal I/O operations active to each device.
	.No See Sx ZFS I/O SCHEDULER .
	.
	.It Sy zfs_vdev_removal_min_active Ns = Ns Sy 1 Pq int
	Minimum removal I/O operations active to each device.
	.No See Sx ZFS I/O SCHEDULER .
	.
	.It Sy zfs_vdev_scrub_max_active Ns = Ns Sy 2 Pq int
	Maximum scrub I/O operations active to each device.
	.No See Sx ZFS I/O SCHEDULER .
	.
	.It Sy zfs_vdev_scrub_min_active Ns = Ns Sy 1 Pq int
	Minimum scrub I/O operations active to each device.
	.No See Sx ZFS I/O SCHEDULER .
	.
	.It Sy zfs_vdev_sync_read_max_active Ns = Ns Sy 10 Pq int
	Maximum synchronous read I/O operations active to each device.
	.No See Sx ZFS I/O SCHEDULER .
	.
	.It Sy zfs_vdev_sync_read_min_active Ns = Ns Sy 10 Pq int
	Minimum synchronous read I/O operations active to each device.
	.No See Sx ZFS I/O SCHEDULER .
	.
	.It Sy zfs_vdev_sync_write_max_active Ns = Ns Sy 10 Pq int
	Maximum synchronous write I/O operations active to each device.
	.No See Sx ZFS I/O SCHEDULER .
	.
	.It Sy zfs_vdev_sync_write_min_active Ns = Ns Sy 10 Pq int
	Minimum synchronous write I/O operations active to each device.
	.No See Sx ZFS I/O SCHEDULER .
	.
	.It Sy zfs_vdev_trim_max_active Ns = Ns Sy 2 Pq int
	Maximum trim/discard I/O operations active to each device.
	.No See Sx ZFS I/O SCHEDULER .
	.
	.It Sy zfs_vdev_trim_min_active Ns = Ns Sy 1 Pq int
	Minimum trim/discard I/O operations active to each device.
	.No See Sx ZFS I/O SCHEDULER .
	.
	.It Sy zfs_vdev_nia_delay Ns = Ns Sy 5 Pq int
	For non-interactive I/O (scrub, resilver, removal, initialize and rebuild),
	the number of concurrently-active I/O operations is limited to
	.Sy zfs_*_min_active ,
	unless the vdev is "idle".
	When there are no interactive I/O operatinons active (synchronous or otherwise),
	and
	.Sy zfs_vdev_nia_delay
	operations have completed since the last interactive operation,
	then the vdev is considered to be "idle",
	and the number of concurrently-active non-interactive operations is increased to
	.Sy zfs_*_max_active .
	.No See Sx ZFS I/O SCHEDULER .
	.
	.It Sy zfs_vdev_nia_credit Ns = Ns Sy 5 Pq int
	Some HDDs tend to prioritize sequential I/O so strongly, that concurrent
	random I/O latency reaches several seconds.
	On some HDDs this happens even if sequential I/O operations
	are submitted one at a time, and so setting
	.Sy zfs_*_max_active Ns = Sy 1
	does not help.
	To prevent non-interactive I/O, like scrub,
	from monopolizing the device, no more than
	.Sy zfs_vdev_nia_credit operations can be sent
	while there are outstanding incomplete interactive operations.
	This enforced wait ensures the HDD services the interactive I/O
	within a reasonable amount of time.
	.No See Sx ZFS I/O SCHEDULER .
	.
	.It Sy zfs_vdev_queue_depth_pct Ns = Ns Sy 1000 Ns % Pq int
	Maximum number of queued allocations per top-level vdev expressed as
	a percentage of
	.Sy zfs_vdev_async_write_max_active ,
	which allows the system to detect devices that are more capable
	of handling allocations and to allocate more blocks to those devices.
	This allows for dynamic allocation distribution when devices are imbalanced,
	as fuller devices will tend to be slower than empty devices.
	.Pp
	Also see
	.Sy zio_dva_throttle_enabled .
	.
	.It Sy zfs_expire_snapshot Ns = Ns Sy 300 Ns s Pq int
	Time before expiring
	.Pa .zfs/snapshot .
	.
	.It Sy zfs_admin_snapshot Ns = Ns Sy 0 Ns \| Ns 1 Pq int
	Allow the creation, removal, or renaming of entries in the
	.Sy .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
	.Em no_root_squash
	option set.
	.
	.It Sy zfs_flags Ns = Ns Sy 0 Pq int
	Set additional debugging flags.
	The following flags may be bitwise-ored together:
	.TS
	box;
	lbz r l 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-memory \fBrange_trees\fP.
	512 ZFS_DEBUG_SET_ERROR Enable \fBSET_ERROR\fP 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 \fBzfs_dbgmsgs\fP for metaslab loading and flushing.
	.TE
	.Sy \& * No Requires debug build.
	.
	.It Sy zfs_free_leak_on_eio Ns = Ns Sy 0 Ns \| Ns 1 Pq int
	If destroy encounters an
	.Sy 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
	.Sy EIO ,
	permanently leak the space from indirect blocks that can not be read,
	and continue to free everything else that it can.
	.Pp
	The default "stalling" behavior is useful if the storage partially
	fails (i.e. some but not all I/O operations 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.
	Note, however, that this case is actually fairly rare.
	.Pp
	Typically pools either
	.Bl -enum -compact -offset 4n -width "1."
	.It
	fail completely (but perhaps temporarily,
	e.g. due to a top-level vdev going offline), or
	.It
	have localized, permanent errors (e.g. disk returns the wrong data
	due to bit flip or firmware bug).
	.El
	In the former case, 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 the latter, 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.
	It is therefore 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.
	.
	.It Sy zfs_free_min_time_ms Ns = Ns Sy 1000 Ns ms Po 1s Pc Pq int
	During a
	.Nm zfs Cm destroy
	operation using the
	.Sy async_destroy
	feature,
	a minimum of this much time will be spent working on freeing blocks per TXG.
	.
	.It Sy zfs_obsolete_min_time_ms Ns = Ns Sy 500 Ns ms Pq int
	Similar to
	.Sy zfs_free_min_time_ms ,
	but for cleanup of old indirection records for removed vdevs.
	.
	.It Sy zfs_immediate_write_sz Ns = Ns Sy 32768 Ns B Po 32kB Pc Pq long
	Largest data block to write to the ZIL.
	Larger blocks will be treated as if the dataset being written to had the
	.Sy logbias Ns = Ns Sy throughput
	property set.
	.
	.It Sy zfs_initialize_value Ns = Ns Sy 16045690984833335022 Po 0xDEADBEEFDEADBEEE Pc Pq ulong
	Pattern written to vdev free space by
	.Xr zpool-initialize 8 .
	.
	.It Sy zfs_initialize_chunk_size Ns = Ns Sy 1048576 Ns B Po 1MB Pc Pq ulong
	Size of writes used by
	.Xr zpool-initialize 8 .
	This option is used by the test suite.
	.
	.It Sy zfs_livelist_max_entries Ns = Ns Sy 500000 Po 5*10^5 Pc Pq ulong
	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.
	.
	.It Sy zfs_livelist_min_percent_shared Ns = Ns Sy 75 Ns % Pq int
	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 livelists no long give us a benefit
	once a clone has been overwritten enough.
	.
	.It Sy zfs_livelist_condense_new_alloc Ns = Ns Sy 0 Pq int
	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.
	.
	.It Sy zfs_livelist_condense_sync_cancel Ns = Ns Sy 0 Pq int
	Incremented each time livelist condensing is canceled while in
	.Fn spa_livelist_condense_sync .
	This option is used by the test suite to track race conditions.
	.
	.It Sy zfs_livelist_condense_sync_pause Ns = Ns Sy 0 Ns \| Ns 1 Pq int
	When set, the livelist condense process pauses indefinitely before
	executing the synctask -
	.Fn spa_livelist_condense_sync .
	This option is used by the test suite to trigger race conditions.
	.
	.It Sy zfs_livelist_condense_zthr_cancel Ns = Ns Sy 0 Pq int
	Incremented each time livelist condensing is canceled while in
	.Fn spa_livelist_condense_cb .
	This option is used by the test suite to track race conditions.
	.
	.It Sy zfs_livelist_condense_zthr_pause Ns = Ns Sy 0 Ns \| Ns 1 Pq int
	When set, the livelist condense process pauses indefinitely before
	executing the open context condensing work in
	.Fn spa_livelist_condense_cb .
	This option is used by the test suite to trigger race conditions.
	.
	.It Sy zfs_lua_max_instrlimit Ns = Ns Sy 100000000 Po 10^8 Pc Pq ulong
	The maximum execution time limit that can be set for a ZFS channel program,
	specified as a number of Lua instructions.
	.
	.It Sy zfs_lua_max_memlimit Ns = Ns Sy 104857600 Po 100MB Pc Pq ulong
	The maximum memory limit that can be set for a ZFS channel program, specified
	in bytes.
	.
	.It Sy zfs_max_dataset_nesting Ns = Ns Sy 50 Pq int
	The maximum depth of nested datasets.
	This value can be tuned temporarily to
	fix existing datasets that exceed the predefined limit.
	.
	.It Sy zfs_max_log_walking Ns = Ns Sy 5 Pq ulong
	The number of past TXGs that the flushing algorithm of the log spacemap
	feature uses to estimate incoming log blocks.
	.
	.It Sy zfs_max_logsm_summary_length Ns = Ns Sy 10 Pq ulong
	Maximum number of rows allowed in the summary of the spacemap log.
	.
	.It Sy zfs_max_recordsize Ns = Ns Sy 1048576 Po 1MB Pc Pq int
	We currently support block sizes from
	.Em 512B No to Em 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 this tunable.
	Larger blocks can be created by changing it,
	and pools with larger blocks can always be imported and used,
	regardless of this setting.
	.
	.It Sy zfs_allow_redacted_dataset_mount Ns = Ns Sy 0 Ns \| Ns 1 Pq int
	Allow datasets received with redacted send/receive to be mounted.
	Normally disabled because these datasets may be missing key data.
	.
	.It Sy zfs_min_metaslabs_to_flush Ns = Ns Sy 1 Pq ulong
	Minimum number of metaslabs to flush per dirty TXG.
	.
	.It Sy zfs_metaslab_fragmentation_threshold Ns = Ns Sy 70 Ns % Pq int
	Allow metaslabs to keep their active state as long as their fragmentation
	percentage is no more than this value.
	An active metaslab that exceeds this threshold
	will no longer keep its active status allowing better metaslabs to be selected.
	.
	.It Sy zfs_mg_fragmentation_threshold Ns = Ns Sy 95 Ns % Pq int
	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.
	.
	.It Sy zfs_mg_noalloc_threshold Ns = Ns Sy 0 Ns % Pq int
	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
	.Sy 0
	disables the feature and causes all metaslab groups to be eligible for allocations.
	.Pp
	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
	.Sy zfs_mg_alloc_failures
	facility.
	.
	.It Sy zfs_ddt_data_is_special Ns = Ns Sy 1 Ns \| Ns 0 Pq int
	If enabled, ZFS will place DDT data into the special allocation class.
	.
	.It Sy zfs_user_indirect_is_special Ns = Ns Sy 1 Ns \| Ns 0 Pq int
	If enabled, ZFS will place user data indirect blocks
	into the special allocation class.
	.
	.It Sy zfs_multihost_history Ns = Ns Sy 0 Pq int
	Historical statistics for this many latest multihost updates will be available in
	.Pa /proc/spl/kstat/zfs/ Ns Ao Ar pool Ac Ns Pa /multihost .
	.
	.It Sy zfs_multihost_interval Ns = Ns Sy 1000 Ns ms Po 1s Pc Pq ulong
	Used to control the frequency of multihost writes which are performed when the
	.Sy multihost
	pool property is on.
	This is one of the factors used to determine the
	length of the activity check during import.
	.Pp
	The multihost write period is
	.Sy zfs_multihost_interval / leaf-vdevs .
	On average a multihost write will be issued for each leaf vdev
	every
	.Sy zfs_multihost_interval
	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.
	.
	.It Sy zfs_multihost_import_intervals Ns = Ns Sy 20 Pq uint
	Used to control the duration of the activity test on import.
	Smaller values of
	.Sy zfs_multihost_import_intervals
	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.
	.Pp
	On import the activity check waits a minimum amount of time determined by
	.Sy zfs_multihost_interval * zfs_multihost_import_intervals ,
	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
	.Sy zfs_multihost_interval .
	A minimum of
	.Em 100ms
	is enforced.
	.Pp
	.Sy 0 No is equivalent to Sy 1 .
	.
	.It Sy zfs_multihost_fail_intervals Ns = Ns Sy 10 Pq uint
	Controls the behavior of the pool when multihost write failures or delays are
	detected.
	.Pp
	When
	.Sy 0 ,
	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.
	.Pp
	Otherwise, the pool will be suspended if
	.Sy zfs_multihost_fail_intervals * zfs_multihost_interval
	milliseconds pass without a successful MMP write.
	This guarantees the activity test will see MMP writes if the pool is imported.
	.Sy 1 No is equivalent to Sy 2 ;
	this is necessary to prevent the pool from being suspended
	due to normal, small I/O latency variations.
	.
	.It Sy zfs_no_scrub_io Ns = Ns Sy 0 Ns \| Ns 1 Pq int
	Set to disable scrub I/O.
	This results in scrubs not actually scrubbing data and
	simply doing a metadata crawl of the pool instead.
	.
	.It Sy zfs_no_scrub_prefetch Ns = Ns Sy 0 Ns \| Ns 1 Pq int
	Set to disable block prefetching for scrubs.
	.
	.It Sy zfs_nocacheflush Ns = Ns Sy 0 Ns \| Ns 1 Pq int
	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.
	.
	.It Sy zfs_nopwrite_enabled Ns = Ns Sy 1 Ns \| Ns 0 Pq int
	Allow no-operation writes.
	The occurrence of nopwrites will further depend on other pool properties
	.Pq i.a. the checksumming and compression algorithms .
	.
	-.It Sy zfs_dmu_offset_next_sync Ns = Ns Sy 0 Ns \| ns 1 Pq int
	+.It Sy zfs_dmu_offset_next_sync Ns = Ns Sy 0 Ns \| Ns 1 Pq int
	Enable forcing TXG sync to find holes.
	When enabled forces ZFS to act like prior versions when
	.Sy SEEK_HOLE No or Sy SEEK_DATA
	flags are used, which, when a dnode is dirty,
	causes TXGs to be synced so that this data can be found.
	.
	.It Sy zfs_pd_bytes_max Ns = Ns Sy 52428800 Ns B Po 50MB Pc Pq int
	The number of bytes which should be prefetched during a pool traversal, like
	.Nm zfs Cm send
	or other data crawling operations.
	.
	.It Sy zfs_traverse_indirect_prefetch_limit Ns = Ns Sy 32 Pq int
	The number of blocks pointed by indirect (non-L0) block which should be
	prefetched during a pool traversal, like
	.Nm zfs Cm send
	or other data crawling operations.
	.
	.It Sy zfs_per_txg_dirty_frees_percent Ns = Ns Sy 5 Ns % Pq ulong
	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.
	.Sy 0 No disables this throttle.
	.
	.It Sy zfs_prefetch_disable Ns = Ns Sy 0 Ns \| Ns 1 Pq int
	Disable predictive prefetch.
	Note that it leaves "prescient" prefetch (for. e.g.\&
	.Nm zfs Cm send )
	intact.
	Unlike predictive prefetch, prescient prefetch never issues I/O
	that ends up not being needed, so it can't hurt performance.
	.
	.It Sy zfs_qat_checksum_disable Ns = Ns Sy 0 Ns \| Ns 1 Pq int
	Disable QAT hardware acceleration for SHA256 checksums.
	May be unset 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.
	.
	.It Sy zfs_qat_compress_disable Ns = Ns Sy 0 Ns \| Ns 1 Pq int
	Disable QAT hardware acceleration for gzip compression.
	May be unset 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.
	.
	.It Sy zfs_qat_encrypt_disable Ns = Ns Sy 0 Ns \| Ns 1 Pq int
	Disable QAT hardware acceleration for AES-GCM encryption.
	May be unset 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.
	.
	.It Sy zfs_vnops_read_chunk_size Ns = Ns Sy 1048576 Ns B Po 1MB Pc Pq long
	Bytes to read per chunk.
	.
	.It Sy zfs_read_history Ns = Ns Sy 0 Pq int
	Historical statistics for this many latest reads will be available in
	.Pa /proc/spl/kstat/zfs/ Ns Ao Ar pool Ac Ns Pa /reads .
	.
	.It Sy zfs_read_history_hits Ns = Ns Sy 0 Ns \| Ns 1 Pq int
	Include cache hits in read history
	.
	.It Sy zfs_rebuild_max_segment Ns = Ns Sy 1048576 Ns B Po 1MB Pc Pq ulong
	Maximum read segment size to issue when sequentially resilvering a
	top-level vdev.
	.
	.It Sy zfs_rebuild_scrub_enabled Ns = Ns Sy 1 Ns \| Ns 0 Pq int
	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 is enabled by default and strongly recommended.
	.
	.It Sy zfs_rebuild_vdev_limit Ns = Ns Sy 33554432 Ns B Po 32MB Pc Pq ulong
	Maximum amount of I/O that can be concurrently issued for a sequential
	resilver per leaf device, given in bytes.
	.
	.It Sy zfs_reconstruct_indirect_combinations_max Ns = Ns Sy 4096 Pq int
	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 this many 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.
	.
	.It Sy zfs_recover Ns = Ns Sy 0 Ns \| Ns 1 Pq int
	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.
	.
	.It Sy zfs_removal_ignore_errors Ns = Ns Sy 0 Ns \| Ns 1 Pq int
	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 hence 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.
	.
	.It Sy zfs_removal_suspend_progress Ns = Ns Sy 0 Ns \| Ns 1 Pq int
	This is used by the test suite so that it can ensure that certain actions
	happen while in the middle of a removal.
	.
	.It Sy zfs_remove_max_segment Ns = Ns Sy 16777216 Ns B Po 16MB Pc Pq int
	The largest contiguous segment that we will attempt to allocate when removing
	a device.
	If there is a performance problem with attempting to allocate large blocks,
	consider decreasing this.
	The default value is also the maximum.
	.
	.It Sy zfs_resilver_disable_defer Ns = Ns Sy 0 Ns \| Ns 1 Pq int
	Ignore the
	.Sy resilver_defer
	feature, causing an operation that would start a resilver to
	immediately restart the one in progress.
	.
	.It Sy zfs_resilver_min_time_ms Ns = Ns Sy 3000 Ns ms Po 3s Pc Pq int
	Resilvers are processed by the sync thread.
	While resilvering, it will spend at least this much time
	working on a resilver between TXG flushes.
	.
	.It Sy zfs_scan_ignore_errors Ns = Ns Sy 0 Ns \| Ns 1 Pq int
	If set, remove the DTL (dirty time list) upon completion of a pool scan (scrub),
	even if there were unrepairable errors.
	Intended to be used during pool repair or recovery to
	stop resilvering when the pool is next imported.
	.
	.It Sy zfs_scrub_min_time_ms Ns = Ns Sy 1000 Ns ms Po 1s Pc Pq int
	Scrubs are processed by the sync thread.
	While scrubbing, it will spend at least this much time
	working on a scrub between TXG flushes.
	.
	.It Sy zfs_scan_checkpoint_intval Ns = Ns Sy 7200 Ns s Po 2h Pc Pq int
	To preserve progress across reboots, the sequential scan algorithm periodically
	needs to stop metadata scanning and issue all the verification I/O to disk.
	The frequency of this flushing is determined by this tunable.
	.
	.It Sy zfs_scan_fill_weight Ns = Ns Sy 3 Pq int
	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.
	.
	.It Sy zfs_scan_issue_strategy Ns = Ns Sy 0 Pq int
	Determines the order that data will be verified while scrubbing or resilvering:
	.Bl -tag -compact -offset 4n -width "a"
	.It Sy 1
	Data will be verified as sequentially as possible, given the
	amount of memory reserved for scrubbing
	.Pq see Sy zfs_scan_mem_lim_fact .
	This may improve scrub performance if the pool's data is very fragmented.
	.It Sy 2
	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.
	.It Sy 0
	.No Use strategy Sy 1 No during normal verification
	.No and strategy Sy 2 No while taking a checkpoint.
	.El
	.
	.It Sy zfs_scan_legacy Ns = Ns Sy 0 Ns \| Ns 1 Pq int
	If unset, indicates that scrubs and resilvers will gather metadata in
	memory before issuing sequential I/O.
	Otherwise indicates that the legacy algorithm will be used,
	where I/O is initiated as soon as it is discovered.
	Unsetting will not affect scrubs or resilvers that are already in progress.
	.
	.It Sy zfs_scan_max_ext_gap Ns = Ns Sy 2097152 Ns B Po 2MB Pc Pq int
	Sets the largest gap in bytes between scrub/resilver I/O operations
	that will still be considered sequential for sorting purposes.
	Changing this value will not
	affect scrubs or resilvers that are already in progress.
	.
	.It Sy zfs_scan_mem_lim_fact Ns = Ns Sy 20 Ns ^-1 Pq int
	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.
	.
	.It Sy zfs_scan_mem_lim_soft_fact Ns = Ns Sy 20 Ns ^-1 Pq int
	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.
	.
	.It Sy zfs_scan_strict_mem_lim Ns = Ns Sy 0 Ns \| Ns 1 Pq int
	Enforce tight memory limits on pool scans when a sequential scan is in progress.
	When disabled, the memory limit may be exceeded by fast disks.
	.
	.It Sy zfs_scan_suspend_progress Ns = Ns Sy 0 Ns \| Ns 1 Pq int
	Freezes a scrub/resilver in progress without actually pausing it.
	Intended for testing/debugging.
	.
	.It Sy zfs_scan_vdev_limit Ns = Ns Sy 4194304 Ns B Po 4MB Pc Pq int
	Maximum amount of data that can be concurrently issued at once for scrubs and
	resilvers per leaf device, given in bytes.
	.
	.It Sy zfs_send_corrupt_data Ns = Ns Sy 0 Ns \| Ns 1 Pq int
	Allow sending of corrupt data (ignore read/checksum errors when sending).
	.
	.It Sy zfs_send_unmodified_spill_blocks Ns = Ns Sy 1 Ns \| Ns 0 Pq int
	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.
	.
	.It Sy zfs_send_no_prefetch_queue_ff Ns = Ns Sy 20 Ns ^-1 Pq int
	The fill fraction of the
	.Nm zfs Cm send
	internal queues.
	The fill fraction controls the timing with which internal threads are woken up.
	.
	.It Sy zfs_send_no_prefetch_queue_length Ns = Ns Sy 1048576 Ns B Po 1MB Pc Pq int
	The maximum number of bytes allowed in
	.Nm zfs Cm send Ns 's
	internal queues.
	.
	.It Sy zfs_send_queue_ff Ns = Ns Sy 20 Ns ^-1 Pq int
	The fill fraction of the
	.Nm zfs Cm send
	prefetch queue.
	The fill fraction controls the timing with which internal threads are woken up.
	.
	.It Sy zfs_send_queue_length Ns = Ns Sy 16777216 Ns B Po 16MB Pc Pq int
	The maximum number of bytes allowed that will be prefetched by
	.Nm zfs Cm send .
	This value must be at least twice the maximum block size in use.
	.
	.It Sy zfs_recv_queue_ff Ns = Ns Sy 20 Ns ^-1 Pq int
	The fill fraction of the
	.Nm zfs Cm receive
	queue.
	The fill fraction controls the timing with which internal threads are woken up.
	.
	.It Sy zfs_recv_queue_length Ns = Ns Sy 16777216 Ns B Po 16MB Pc Pq int
	The maximum number of bytes allowed in the
	.Nm zfs Cm receive
	queue.
	This value must be at least twice the maximum block size in use.
	.
	.It Sy zfs_recv_write_batch_size Ns = Ns Sy 1048576 Ns B Po 1MB Pc Pq int
	The maximum amount of data, in bytes, that
	.Nm zfs Cm receive
	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
	.Sy 32MB .
	.
	.It Sy zfs_override_estimate_recordsize Ns = Ns Sy 0 Ns \| Ns 1 Pq ulong
	Setting this variable overrides the default logic for estimating block
	sizes when doing a
	.Nm zfs Cm 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.
	.
	.It Sy zfs_sync_pass_deferred_free Ns = Ns Sy 2 Pq int
	Flushing of data to disk is done in passes.
	Defer frees starting in this pass.
	.
	.It Sy zfs_spa_discard_memory_limit Ns = Ns Sy 16777216 Ns B Po 16MB Pc Pq int
	Maximum memory used for prefetching a checkpoint's space map on each
	vdev while discarding the checkpoint.
	.
	.It Sy zfs_special_class_metadata_reserve_pct Ns = Ns Sy 25 Ns % Pq int
	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 metadata as the
	special vdevs approach capacity.
	.
	.It Sy zfs_sync_pass_dont_compress Ns = Ns Sy 8 Pq int
	Starting in this sync pass, disable compression (including of metadata).
	With the default setting, in practice, we don't have this many sync passes,
	so this has no effect.
	.Pp
	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,
	many blocks' size will change, and thus we have to re-allocate
	(not overwrite) them.
	It also increases the number of
	.Em 128kB
	allocations (e.g. for indirect blocks and spacemaps)
	because these will not be compressed.
	The
	.Em 128kB
	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 these allocations.
	.
	.It Sy zfs_sync_pass_rewrite Ns = Ns Sy 2 Pq int
	Rewrite new block pointers starting in this pass.
	.
	.It Sy zfs_sync_taskq_batch_pct Ns = Ns Sy 75 Ns % Pq int
	This controls the number of threads used by
	.Sy dp_sync_taskq .
	The default value of
	.Sy 75%
	will create a maximum of one thread per CPU.
	.
	.It Sy zfs_trim_extent_bytes_max Ns = Ns Sy 134217728 Ns B Po 128MB Pc Pq uint
	Maximum size of TRIM command.
	Larger ranges will be split into chunks no larger than this value before issuing.
	.
	.It Sy zfs_trim_extent_bytes_min Ns = Ns Sy 32768 Ns B Po 32kB Pc Pq uint
	Minimum size of TRIM commands.
	TRIM ranges smaller than this will be skipped,
	unless they're part of a larger range which was chunked.
	This is done because it's common for these small TRIMs
	to negatively impact overall performance.
	.
	.It Sy zfs_trim_metaslab_skip Ns = Ns Sy 0 Ns \| Ns 1 Pq uint
	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 pool's 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.
	.
	.It Sy zfs_trim_queue_limit Ns = Ns Sy 10 Pq uint
	Maximum number of queued TRIMs outstanding per leaf vdev.
	The number of concurrent TRIM commands issued to the device is controlled by
	.Sy zfs_vdev_trim_min_active No and Sy zfs_vdev_trim_max_active .
	.
	.It Sy zfs_trim_txg_batch Ns = Ns Sy 32 Pq uint
	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.
	.Pp
	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 of
	.Sy 32
	was determined to be a reasonable compromise.
	.
	.It Sy zfs_txg_history Ns = Ns Sy 0 Pq int
	Historical statistics for this many latest TXGs will be available in
	.Pa /proc/spl/kstat/zfs/ Ns Ao Ar pool Ac Ns Pa /TXGs .
	.
	.It Sy zfs_txg_timeout Ns = Ns Sy 5 Ns s Pq int
	Flush dirty data to disk at least every this many seconds (maximum TXG duration).
	.
	.It Sy zfs_vdev_aggregate_trim Ns = Ns Sy 0 Ns \| Ns 1 Pq int
	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.
	.
	.It Sy zfs_vdev_aggregation_limit Ns = Ns Sy 1048576 Ns B Po 1MB Pc Pq int
	Max vdev I/O aggregation size.
	.
	.It Sy zfs_vdev_aggregation_limit_non_rotating Ns = Ns Sy 131072 Ns B Po 128kB Pc Pq int
	Max vdev I/O aggregation size for non-rotating media.
	.
	.It Sy zfs_vdev_cache_bshift Ns = Ns Sy 16 Po 64kB Pc Pq int
	Shift size to inflate reads to.
	.
	.It Sy zfs_vdev_cache_max Ns = Ns Sy 16384 Ns B Po 16kB Pc Pq int
	Inflate reads smaller than this value to meet the
	.Sy zfs_vdev_cache_bshift
	size
	.Pq default Sy 64kB .
	.
	.It Sy zfs_vdev_cache_size Ns = Ns Sy 0 Pq int
	Total size of the per-disk cache in bytes.
	.Pp
	Currently this feature is disabled, as it has been found to not be helpful
	for performance and in some cases harmful.
	.
	.It Sy zfs_vdev_mirror_rotating_inc Ns = Ns Sy 0 Pq int
	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 operation
	immediately follows its predecessor on rotational vdevs
	for the purpose of making decisions based on load.
	.
	.It Sy zfs_vdev_mirror_rotating_seek_inc Ns = Ns Sy 5 Pq int
	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 operation
	lacks locality as defined by
	.Sy zfs_vdev_mirror_rotating_seek_offset .
	Operations within this that are not immediately following the previous operation
	are incremented by half.
	.
	.It Sy zfs_vdev_mirror_rotating_seek_offset Ns = Ns Sy 1048576 Ns B Po 1MB Pc Pq int
	The maximum distance for the last queued I/O operation in which
	the balancing algorithm considers an operation to have locality.
	.No See Sx ZFS I/O SCHEDULER .
	.
	.It Sy zfs_vdev_mirror_non_rotating_inc Ns = Ns Sy 0 Pq int
	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/O operations do not immediately follow one another.
	.
	.It Sy zfs_vdev_mirror_non_rotating_seek_inc Ns = Ns Sy 1 Pq int
	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 operation lacks
	locality as defined by the
	.Sy zfs_vdev_mirror_rotating_seek_offset .
	Operations within this that are not immediately following the previous operation
	are incremented by half.
	.
	.It Sy zfs_vdev_read_gap_limit Ns = Ns Sy 32768 Ns B Po 32kB Pc Pq int
	Aggregate read I/O operations if the on-disk gap between them is within this
	threshold.
	.
	.It Sy zfs_vdev_write_gap_limit Ns = Ns Sy 4096 Ns B Po 4kB Pc Pq int
	Aggregate write I/O operations if the on-disk gap between them is within this
	threshold.
	.
	.It Sy zfs_vdev_raidz_impl Ns = Ns Sy fastest Pq string
	Select the raidz parity implementation to use.
	.Pp
	Variants that don't depend on CPU-specific features
	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.
	.Pp
	Once the module is loaded,
	.Pa /sys/module/zfs/parameters/zfs_vdev_raidz_impl
	will show the available options,
	with the currently selected one enclosed in square brackets.
	.Pp
	.TS
	lb l l .
	fastest selected by built-in benchmark
	original original implementation
	scalar scalar implementation
	sse2 SSE2 instruction set 64-bit x86
	ssse3 SSSE3 instruction set 64-bit x86
	avx2 AVX2 instruction set 64-bit x86
	avx512f AVX512F instruction set 64-bit x86
	avx512bw AVX512F & AVX512BW instruction sets 64-bit x86
	aarch64_neon NEON Aarch64/64-bit ARMv8
	aarch64_neonx2 NEON with more unrolling Aarch64/64-bit ARMv8
	powerpc_altivec Altivec PowerPC
	.TE
	.
	.It Sy zfs_vdev_scheduler Pq charp
	.Sy DEPRECATED .
	Prints warning to kernel log for compatibility.
	.
	.It Sy zfs_zevent_len_max Ns = Ns Sy 512 Pq int
	Max event queue length.
	Events in the queue can be viewed with
	.Xr zpool-events 8 .
	.
	.It Sy zfs_zevent_retain_max Ns = Ns Sy 2000 Pq int
	Maximum recent zevent records to retain for duplicate checking.
	Setting this to
	.Sy 0
	disables duplicate detection.
	.
	.It Sy zfs_zevent_retain_expire_secs Ns = Ns Sy 900 Ns s Po 15min Pc Pq int
	Lifespan for a recent ereport that was retained for duplicate checking.
	.
	.It Sy zfs_zil_clean_taskq_maxalloc Ns = Ns Sy 1048576 Pq int
	The maximum number of taskq entries that are allowed to be cached.
	When this limit is exceeded transaction records (itxs)
	will be cleaned synchronously.
	.
	.It Sy zfs_zil_clean_taskq_minalloc Ns = Ns Sy 1024 Pq int
	The number of taskq entries that are pre-populated when the taskq is first
	created and are immediately available for use.
	.
	.It Sy zfs_zil_clean_taskq_nthr_pct Ns = Ns Sy 100 Ns % Pq int
	This controls the number of threads used by
	.Sy dp_zil_clean_taskq .
	The default value of
	.Sy 100%
	will create a maximum of one thread per cpu.
	.
	.It Sy zil_maxblocksize Ns = Ns Sy 131072 Ns B Po 128kB Pc Pq int
	This sets the maximum block size used by the ZIL.
	On very fragmented pools, lowering this
	.Pq typically to Sy 36kB
	can improve performance.
	.
	.It Sy zil_nocacheflush Ns = Ns Sy 0 Ns \| Ns 1 Pq int
	Disable the cache flush commands that are normally sent to disk 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.
	.
	.It Sy zil_replay_disable Ns = Ns Sy 0 Ns \| Ns 1 Pq int
	Disable intent logging replay.
	Can be disabled for recovery from corrupted ZIL.
	.
	.It Sy zil_slog_bulk Ns = Ns Sy 786432 Ns B Po 768kB Pc Pq ulong
	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.
	.
	.It Sy zfs_embedded_slog_min_ms Ns = Ns Sy 64 Pq int
	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
	.Sy 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.
	.
	.It Sy zio_deadman_log_all Ns = Ns Sy 0 Ns \| Ns 1 Pq int
	If non-zero, the zio deadman will produce debugging messages
	.Pq see Sy zfs_dbgmsg_enable
	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.
	.
	.It Sy zio_slow_io_ms Ns = Ns Sy 30000 Ns ms Po 30s Pc Pq int
	When an I/O operation takes more than this much time to complete,
	it's marked as slow.
	Each slow operation causes a delay zevent.
	Slow I/O counters can be seen with
	.Nm zpool Cm status Fl s .
	.
	.It Sy zio_dva_throttle_enabled Ns = Ns Sy 1 Ns \| Ns 0 Pq int
	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
	.Sy zfs_vdev_queue_depth_pct .
	.
	.It Sy zio_requeue_io_start_cut_in_line Ns = Ns Sy 0 Ns \| Ns 1 Pq int
	Prioritize requeued I/O.
	.
	.It Sy zio_taskq_batch_pct Ns = Ns Sy 80 Ns % Pq uint
	Percentage of online CPUs 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.
	.Pp
	The default value of
	.Sy 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.
	.
	.It Sy zio_taskq_batch_tpq Ns = Ns Sy 0 Pq uint
	Number of worker threads per taskq.
	Lower values improve I/O ordering and CPU utilization,
	while higher reduces lock contention.
	.Pp
	If
	.Sy 0 ,
	generate a system-dependent value close to 6 threads per taskq.
	.
	.It Sy zvol_inhibit_dev Ns = Ns Sy 0 Ns \| Ns 1 Pq uint
	Do not create zvol device nodes.
	This may slightly improve startup time on
	systems with a very large number of zvols.
	.
	.It Sy zvol_major Ns = Ns Sy 230 Pq uint
	Major number for zvol block devices.
	.
	.It Sy zvol_max_discard_blocks Ns = Ns Sy 16384 Pq ulong
	Discard (TRIM) operations done on zvols will be done in batches of this
	many blocks, where block size is determined by the
	.Sy volblocksize
	property of a zvol.
	.
	.It Sy zvol_prefetch_bytes Ns = Ns Sy 131072 Ns B Po 128kB Pc Pq uint
	When adding a zvol to the system, prefetch this many bytes
	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
	.Xr blkid 8
	or the kernel partitioner.
	.
	.It Sy zvol_request_sync Ns = Ns Sy 0 Ns \| Ns 1 Pq uint
	When processing I/O requests for a zvol, submit them synchronously.
	This effectively limits the queue depth to
	.Em 1
	for each I/O submitter.
	When unset, requests are handled asynchronously by a thread pool.
	The number of requests which can be handled concurrently is controlled by
	.Sy zvol_threads .
	.
	.It Sy zvol_threads Ns = Ns Sy 32 Pq uint
	Max number of threads which can handle zvol I/O requests concurrently.
	.
	.It Sy zvol_volmode Ns = Ns Sy 1 Pq uint
	Defines zvol block devices behaviour when
	.Sy volmode Ns = Ns Sy default :
	.Bl -tag -compact -offset 4n -width "a"
	.It Sy 1
	.No equivalent to Sy full
	.It Sy 2
	.No equivalent to Sy dev
	.It Sy 3
	.No equivalent to Sy none
	.El
	.El
	.
	.Sh ZFS I/O SCHEDULER
	ZFS issues I/O operations to leaf vdevs to satisfy and complete I/O operations.
	The scheduler determines when and in what order those operations are issued.
	The 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,
	.Sy zfs_vdev_max_active .
	Note that the sum of the per-queue minima must not exceed the aggregate maximum.
	If the sum of the per-queue maxima exceeds the aggregate maximum,
	then the number of active operations may reach
	.Sy zfs_vdev_max_active ,
	in which case no further operations will be issued,
	regardless of whether all per-queue minima have been met.
	.Pp
	For many physical devices, throughput increases with the number of
	concurrent operations, but latency typically suffers.
	Furthermore, physical devices typically have a limit
	at which more concurrent operations have no
	effect on throughput or can actually cause it to decrease.
	.Pp
	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 operation is queued or an operation completes,
	the scheduler looks for new operations to issue.
	.Pp
	In general, smaller
	.Sy max_active Ns s
	will lead to lower latency of synchronous operations.
	Larger
	.Sy max_active Ns s
	may lead to higher overall throughput, depending on underlying storage.
	.Pp
	The ratio of the queues'
	.Sy max_active Ns s
	determines the balance of performance between reads, writes, and scrubs.
	For example, increasing
	.Sy zfs_vdev_scrub_max_active
	will cause the scrub or resilver to complete more quickly,
	but reads and writes to have higher latency and lower throughput.
	.Pp
	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 operations
	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.
	.
	.Ss Async Writes
	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:
	.Bd -literal
	\| o---------\| <-- \fBzfs_vdev_async_write_max_active\fP
	^ \| /^ \|
	\| \| / \| \|
	active \| / \| \|
	I/O \| / \| \|
	count \| / \| \|
	\| / \| \|
	\|-------o \| \| <-- \fBzfs_vdev_async_write_min_active\fP
	0\|_______^______\|_________\|
	0% \| \| 100% of \fBzfs_dirty_data_max\fP
	\| \|
	\| `-- \fBzfs_vdev_async_write_active_max_dirty_percent\fP
	`--------- \fBzfs_vdev_async_write_active_min_dirty_percent\fP
	.Ed
	.Pp
	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.
	.Pp
	Ideally, the amount of dirty data on a busy pool will stay in the sloped
	part of the function between
	.Sy zfs_vdev_async_write_active_min_dirty_percent
	and
	.Sy zfs_vdev_async_write_active_max_dirty_percent .
	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.
	.Pp
	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.
	.Pp
	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.
	.Pp
	The minimum time for a transaction to take is calculated as
	.Dl min_time = min( Ns Sy zfs_delay_scale No * (dirty - min) / (max - dirty), 100ms)
	.Pp
	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
	.Sy zfs_delay_min_dirty_percent .
	This should typically be at or above
	.Sy zfs_vdev_async_write_active_max_dirty_percent ,
	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
	.Sy zfs_delay_scale .
	Roughly speaking, this variable determines the amount of delay at the midpoint of the curve.
	.Bd -literal
	delay
	10ms +-------------------------------------------------------------*+
	\| *\|
	9ms + *+
	\| *\|
	8ms + *+
	\| * \|
	7ms + * +
	\| * \|
	6ms + * +
	\| * \|
	5ms + * +
	\| * \|
	4ms + * +
	\| * \|
	3ms + * +
	\| * \|
	2ms + (midpoint) * +
	\| \| ** \|
	1ms + v *** +
	\| \fBzfs_delay_scale\fP ----------> ******** \|
	0 +-------------------------------------*********----------------+
	0% <- \fBzfs_dirty_data_max\fP -> 100%
	.Ed
	.Pp
	Note, that since the delay is added to the outstanding time remaining on the
	most recent transaction it's effectively the inverse of IOPS.
	Here, the midpoint of
	.Em 500us
	translates to
	.Em 2000 IOPS .
	The shape of the curve
	was chosen such that small changes in the amount of accumulated dirty data
	in the first three quarters of the curve yield relatively small differences
	in the amount of delay.
	.Pp
	The effects can be easier to understand when the amount of delay is
	represented on a logarithmic scale:
	.Bd -literal
	delay
	100ms +-------------------------------------------------------------++
	+ +
	\| \|
	+ *+
	10ms + *+
	+ ** +
	\| (midpoint) ** \|
	+ \| ** +
	1ms + v **** +
	+ \fBzfs_delay_scale\fP ----------> ***** +
	\| **** \|
	+ **** +
	100us + ** +
	+ * +
	\| * \|
	+ * +
	10us + * +
	+ +
	\| \|
	+ +
	+--------------------------------------------------------------+
	0% <- \fBzfs_dirty_data_max\fP -> 100%
	.Ed
	.Pp
	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 back-end storage,
	and then by changing the value of
	.Sy zfs_delay_scale
	to increase the steepness of the curve.
	diff --git a/sys/contrib/openzfs/module/Makefile.in b/sys/contrib/openzfs/module/Makefile.in
	index 089b3ff88490..05c673231cc5 100644
	--- a/sys/contrib/openzfs/module/Makefile.in
	+++ b/sys/contrib/openzfs/module/Makefile.in
	@@ -1,140 +1,142 @@
	include Kbuild

	INSTALL_MOD_DIR ?= extra

	SUBDIR_TARGETS = icp lua zstd

	all: modules
	distclean maintainer-clean: clean
	install: modules_install
	uninstall: modules_uninstall
	check:

	.PHONY: all distclean maintainer-clean install uninstall check distdir \
	modules modules-Linux modules-FreeBSD modules-unknown \
	clean clean-Linux clean-FreeBSD \
	modules_install modules_install-Linux modules_install-FreeBSD \
	modules_uninstall modules_uninstall-Linux modules_uninstall-FreeBSD \
	cppcheck cppcheck-Linux cppcheck-FreeBSD

	# For FreeBSD, use debug options from ./configure if not overridden.
	export WITH_DEBUG ?= @WITH_DEBUG@
	export WITH_INVARIANTS ?= @WITH_INVARIANTS@

	# Filter out options that FreeBSD make doesn't understand
	getflags = ( \
	set -- \
	$(filter-out --%,$(firstword $(MFLAGS))) \
	$(filter -I%,$(MFLAGS)) \
	$(filter -j%,$(MFLAGS)); \
	fmakeflags=""; \
	while getopts :deiI:j:knqrstw flag; do \
	case $$flag in \
	\?) :;; \
	:) if [ $$OPTARG = "j" ]; then \
	ncpus=$$(sysctl -n kern.smp.cpus 2>/dev/null \|\| :); \
	if [ -n "$$ncpus" ]; then fmakeflags="$$fmakeflags -j$$ncpus"; fi; \
	fi;; \
	d) fmakeflags="$$fmakeflags -dA";; \
	*) fmakeflags="$$fmakeflags -$$flag$$OPTARG";; \
	esac; \
	done; \
	echo $$fmakeflags \
	)
	FMAKEFLAGS = -C @abs_srcdir@ -f Makefile.bsd $(shell $(getflags))

	ifneq (@abs_srcdir@,@abs_builddir@)
	FMAKEFLAGS += MAKEOBJDIR=@abs_builddir@
	endif

	FMAKE = env -u MAKEFLAGS make $(FMAKEFLAGS)

	modules-Linux:
	list='$(SUBDIR_TARGETS)'; for targetdir in $$list; do \
	$(MAKE) -C $$targetdir; \
	done
	$(MAKE) -C @LINUX_OBJ@ M=`pwd` @KERNEL_MAKE@ CONFIG_ZFS=m modules

	modules-FreeBSD:
	+$(FMAKE)

	modules-unknown:
	@true

	modules: modules-@ac_system@

	clean-Linux:
	@# Only cleanup the kernel build directories when CONFIG_KERNEL
	@# is defined. This indicates that kernel modules should be built.
	@CONFIG_KERNEL_TRUE@ $(MAKE) -C @LINUX_OBJ@ M=`pwd` @KERNEL_MAKE@ clean

	if [ -f @LINUX_SYMBOLS@ ]; then $(RM) @LINUX_SYMBOLS@; fi
	if [ -f Module.markers ]; then $(RM) Module.markers; fi

	find . -name '*.ur-safe' -type f -print \| xargs $(RM)

	clean-FreeBSD:
	+$(FMAKE) clean

	clean: clean-@ac_system@

	modules_install-Linux:
	@# Install the kernel modules
	$(MAKE) -C @LINUX_OBJ@ M=`pwd` modules_install \
	INSTALL_MOD_PATH=$(DESTDIR)$(INSTALL_MOD_PATH) \
	INSTALL_MOD_DIR=$(INSTALL_MOD_DIR) \
	KERNELRELEASE=@LINUX_VERSION@
	@# Remove extraneous build products when packaging
	kmoddir=$(DESTDIR)$(INSTALL_MOD_PATH)/lib/modules/@LINUX_VERSION@; \
	if [ -n "$(DESTDIR)" ]; then \
	find $$kmoddir -name 'modules.*' \| xargs $(RM); \
	fi
	sysmap=$(DESTDIR)$(INSTALL_MOD_PATH)/boot/System.map-@LINUX_VERSION@; \
	if [ -f $$sysmap ]; then \
	depmod -ae -F $$sysmap @LINUX_VERSION@; \
	fi

	modules_install-FreeBSD:
	@# Install the kernel modules
	+$(FMAKE) install

	modules_install: modules_install-@ac_system@

	modules_uninstall-Linux:
	@# Uninstall the kernel modules
	kmoddir=$(DESTDIR)$(INSTALL_MOD_PATH)/lib/modules/@LINUX_VERSION@; \
	for objdir in $(ZFS_MODULES); do \
	$(RM) -R $$kmoddir/$(INSTALL_MOD_DIR)/$$objdir; \
	done

	modules_uninstall-FreeBSD:
	@false

	modules_uninstall: modules_uninstall-@ac_system@

	cppcheck-Linux:
	@CPPCHECK@ -j@CPU_COUNT@ --std=c99 --quiet --force --error-exitcode=2 \
	- --inline-suppr --suppress=noValidConfiguration \
	+ --inline-suppr \
	+ --suppress=unmatchedSuppression \
	+ --suppress=noValidConfiguration \
	--enable=warning,information -D_KERNEL \
	--include=@LINUX_OBJ@/include/generated/autoconf.h \
	--include=@top_srcdir@/zfs_config.h \
	--config-exclude=@LINUX_OBJ@/include \
	-I @LINUX_OBJ@/include \
	-I @top_srcdir@/include/os/linux/kernel \
	-I @top_srcdir@/include/os/linux/spl \
	-I @top_srcdir@/include/os/linux/zfs \
	-I @top_srcdir@/include \
	avl icp lua nvpair spl unicode zcommon zfs zstd os/linux

	cppcheck-FreeBSD:
	@true

	cppcheck: cppcheck-@ac_system@

	distdir:
	(cd @srcdir@ && find $(ZFS_MODULES) os -name '*.[chS]') \| \
	while read path; do \
	mkdir -p $$distdir/$${path%/*}; \
	cp @srcdir@/$$path $$distdir/$$path; \
	done; \
	cp @srcdir@/Makefile.bsd $$distdir/Makefile.bsd
	diff --git a/sys/contrib/openzfs/module/icp/core/kcf_prov_tabs.c b/sys/contrib/openzfs/module/icp/core/kcf_prov_tabs.c
	index 94e6937bcd76..9d303d022517 100644
	--- a/sys/contrib/openzfs/module/icp/core/kcf_prov_tabs.c
	+++ b/sys/contrib/openzfs/module/icp/core/kcf_prov_tabs.c
	@@ -1,645 +1,645 @@
	/*
	* 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.
	*/

	/*
	* This file is part of the core Kernel Cryptographic Framework.
	* It implements the management of tables of Providers. Entries to
	* added and removed when cryptographic providers register with
	* and unregister from the framework, respectively. The KCF scheduler
	* and ioctl pseudo driver call this function to obtain the list
	* of available providers.
	*
	* The provider table is indexed by crypto_provider_id_t. Each
	* element of the table contains a pointer to a provider descriptor,
	* or NULL if the entry is free.
	*
	* This file also implements helper functions to allocate and free
	* provider descriptors.
	*/

	#include <sys/zfs_context.h>
	#include <sys/crypto/common.h>
	#include <sys/crypto/impl.h>
	#include <sys/crypto/sched_impl.h>
	#include <sys/crypto/spi.h>

	#define KCF_MAX_PROVIDERS 512 /* max number of providers */

	/*
	* Prov_tab is an array of providers which is updated when
	* a crypto provider registers with kcf. The provider calls the
	* SPI routine, crypto_register_provider(), which in turn calls
	* kcf_prov_tab_add_provider().
	*
	* A provider unregisters by calling crypto_unregister_provider()
	* which triggers the removal of the prov_tab entry.
	* It also calls kcf_remove_mech_provider().
	*
	* prov_tab entries are not updated from kcf.conf or by cryptoadm(1M).
	*/
	static kcf_provider_desc_t **prov_tab = NULL;
	static kmutex_t prov_tab_mutex; /* ensure exclusive access to the table */
	static uint_t prov_tab_num = 0; /* number of providers in table */
	static uint_t prov_tab_max = KCF_MAX_PROVIDERS;

	void
	kcf_prov_tab_destroy(void)
	{
	mutex_destroy(&prov_tab_mutex);

	if (prov_tab)
	kmem_free(prov_tab, prov_tab_max *
	sizeof (kcf_provider_desc_t *));
	}

	/*
	* Initialize a mutex and the KCF providers table, prov_tab.
	* The providers table is dynamically allocated with prov_tab_max entries.
	* Called from kcf module _init().
	*/
	void
	kcf_prov_tab_init(void)
	{
	mutex_init(&prov_tab_mutex, NULL, MUTEX_DEFAULT, NULL);

	prov_tab = kmem_zalloc(prov_tab_max * sizeof (kcf_provider_desc_t *),
	KM_SLEEP);
	}

	/*
	* Add a provider to the provider table. If no free entry can be found
	* for the new provider, returns CRYPTO_HOST_MEMORY. Otherwise, add
	* the provider to the table, initialize the pd_prov_id field
	* of the specified provider descriptor to the index in that table,
	* and return CRYPTO_SUCCESS. Note that a REFHOLD is done on the
	* provider when pointed to by a table entry.
	*/
	int
	kcf_prov_tab_add_provider(kcf_provider_desc_t *prov_desc)
	{
	uint_t i;

	ASSERT(prov_tab != NULL);

	mutex_enter(&prov_tab_mutex);

	/* find free slot in providers table */
	for (i = 1; i < KCF_MAX_PROVIDERS && prov_tab[i] != NULL; i++)
	;
	if (i == KCF_MAX_PROVIDERS) {
	/* ran out of providers entries */
	mutex_exit(&prov_tab_mutex);
	cmn_err(CE_WARN, "out of providers entries");
	return (CRYPTO_HOST_MEMORY);
	}

	/* initialize entry */
	prov_tab[i] = prov_desc;
	KCF_PROV_REFHOLD(prov_desc);
	KCF_PROV_IREFHOLD(prov_desc);
	prov_tab_num++;

	mutex_exit(&prov_tab_mutex);

	/* update provider descriptor */
	prov_desc->pd_prov_id = i;

	/*
	* The KCF-private provider handle is defined as the internal
	* provider id.
	*/
	prov_desc->pd_kcf_prov_handle =
	(crypto_kcf_provider_handle_t)prov_desc->pd_prov_id;

	return (CRYPTO_SUCCESS);
	}

	/*
	* Remove the provider specified by its id. A REFRELE is done on the
	* corresponding provider descriptor before this function returns.
	* Returns CRYPTO_UNKNOWN_PROVIDER if the provider id is not valid.
	*/
	int
	kcf_prov_tab_rem_provider(crypto_provider_id_t prov_id)
	{
	kcf_provider_desc_t *prov_desc;

	ASSERT(prov_tab != NULL);
	ASSERT(prov_tab_num >= 0);

	/*
	* Validate provider id, since it can be specified by a 3rd-party
	* provider.
	*/

	mutex_enter(&prov_tab_mutex);
	if (prov_id >= KCF_MAX_PROVIDERS \|\|
	((prov_desc = prov_tab[prov_id]) == NULL)) {
	mutex_exit(&prov_tab_mutex);
	return (CRYPTO_INVALID_PROVIDER_ID);
	}
	mutex_exit(&prov_tab_mutex);

	/*
	* The provider id must remain valid until the associated provider
	* descriptor is freed. For this reason, we simply release our
	* reference to the descriptor here. When the reference count
	* reaches zero, kcf_free_provider_desc() will be invoked and
	* the associated entry in the providers table will be released
	* at that time.
	*/

	KCF_PROV_REFRELE(prov_desc);
	KCF_PROV_IREFRELE(prov_desc);

	return (CRYPTO_SUCCESS);
	}

	/*
	* Returns the provider descriptor corresponding to the specified
	* provider id. A REFHOLD is done on the descriptor before it is
	* returned to the caller. It is the responsibility of the caller
	* to do a REFRELE once it is done with the provider descriptor.
	*/
	kcf_provider_desc_t *
	kcf_prov_tab_lookup(crypto_provider_id_t prov_id)
	{
	kcf_provider_desc_t *prov_desc;

	mutex_enter(&prov_tab_mutex);

	prov_desc = prov_tab[prov_id];

	if (prov_desc == NULL) {
	mutex_exit(&prov_tab_mutex);
	return (NULL);
	}

	KCF_PROV_REFHOLD(prov_desc);

	mutex_exit(&prov_tab_mutex);

	return (prov_desc);
	}

	static void
	allocate_ops_v1(crypto_ops_t src, crypto_ops_t dst, uint_t *mech_list_count)
	{
	if (src->co_control_ops != NULL)
	dst->co_control_ops = kmem_alloc(sizeof (crypto_control_ops_t),
	KM_SLEEP);

	if (src->co_digest_ops != NULL)
	dst->co_digest_ops = kmem_alloc(sizeof (crypto_digest_ops_t),
	KM_SLEEP);

	if (src->co_cipher_ops != NULL)
	dst->co_cipher_ops = kmem_alloc(sizeof (crypto_cipher_ops_t),
	KM_SLEEP);

	if (src->co_mac_ops != NULL)
	dst->co_mac_ops = kmem_alloc(sizeof (crypto_mac_ops_t),
	KM_SLEEP);

	if (src->co_sign_ops != NULL)
	dst->co_sign_ops = kmem_alloc(sizeof (crypto_sign_ops_t),
	KM_SLEEP);

	if (src->co_verify_ops != NULL)
	dst->co_verify_ops = kmem_alloc(sizeof (crypto_verify_ops_t),
	KM_SLEEP);

	if (src->co_dual_ops != NULL)
	dst->co_dual_ops = kmem_alloc(sizeof (crypto_dual_ops_t),
	KM_SLEEP);

	if (src->co_dual_cipher_mac_ops != NULL)
	dst->co_dual_cipher_mac_ops = kmem_alloc(
	sizeof (crypto_dual_cipher_mac_ops_t), KM_SLEEP);

	if (src->co_random_ops != NULL) {
	dst->co_random_ops = kmem_alloc(
	sizeof (crypto_random_number_ops_t), KM_SLEEP);

	/*
	* Allocate storage to store the array of supported mechanisms
	* specified by provider. We allocate extra mechanism storage
	* if the provider has random_ops since we keep an internal
	* mechanism, SUN_RANDOM, in this case.
	*/
	(*mech_list_count)++;
	}

	if (src->co_session_ops != NULL)
	dst->co_session_ops = kmem_alloc(sizeof (crypto_session_ops_t),
	KM_SLEEP);

	if (src->co_object_ops != NULL)
	dst->co_object_ops = kmem_alloc(sizeof (crypto_object_ops_t),
	KM_SLEEP);

	if (src->co_key_ops != NULL)
	dst->co_key_ops = kmem_alloc(sizeof (crypto_key_ops_t),
	KM_SLEEP);

	if (src->co_provider_ops != NULL)
	dst->co_provider_ops = kmem_alloc(
	sizeof (crypto_provider_management_ops_t), KM_SLEEP);

	if (src->co_ctx_ops != NULL)
	dst->co_ctx_ops = kmem_alloc(sizeof (crypto_ctx_ops_t),
	KM_SLEEP);
	}

	static void
	allocate_ops_v2(crypto_ops_t src, crypto_ops_t dst)
	{
	if (src->co_mech_ops != NULL)
	dst->co_mech_ops = kmem_alloc(sizeof (crypto_mech_ops_t),
	KM_SLEEP);
	}

	static void
	allocate_ops_v3(crypto_ops_t src, crypto_ops_t dst)
	{
	if (src->co_nostore_key_ops != NULL)
	dst->co_nostore_key_ops =
	kmem_alloc(sizeof (crypto_nostore_key_ops_t), KM_SLEEP);
	}

	/*
	* Allocate a provider descriptor. mech_list_count specifies the
	* number of mechanisms supported by the providers, and is used
	* to allocate storage for the mechanism table.
	* This function may sleep while allocating memory, which is OK
	* since it is invoked from user context during provider registration.
	*/
	kcf_provider_desc_t *
	kcf_alloc_provider_desc(crypto_provider_info_t *info)
	{
	int i, j;
	kcf_provider_desc_t *desc;
	uint_t mech_list_count = info->pi_mech_list_count;
	crypto_ops_t *src_ops = info->pi_ops_vector;

	desc = kmem_zalloc(sizeof (kcf_provider_desc_t), KM_SLEEP);

	/*
	* pd_description serves two purposes
	* - Appears as a blank padded PKCS#11 style string, that will be
	* returned to applications in CK_SLOT_INFO.slotDescription.
	* This means that we should not have a null character in the
	* first CRYPTO_PROVIDER_DESCR_MAX_LEN bytes.
	* - Appears as a null-terminated string that can be used by
	* other kcf routines.
	*
	* So, we allocate enough room for one extra null terminator
	* which keeps every one happy.
	*/
	desc->pd_description = kmem_alloc(CRYPTO_PROVIDER_DESCR_MAX_LEN + 1,
	KM_SLEEP);
	(void) memset(desc->pd_description, ' ',
	CRYPTO_PROVIDER_DESCR_MAX_LEN);
	desc->pd_description[CRYPTO_PROVIDER_DESCR_MAX_LEN] = '\0';

	/*
	* Since the framework does not require the ops vector specified
	* by the providers during registration to be persistent,
	* KCF needs to allocate storage where copies of the ops
	* vectors are copied.
	*/
	desc->pd_ops_vector = kmem_zalloc(sizeof (crypto_ops_t), KM_SLEEP);

	if (info->pi_provider_type != CRYPTO_LOGICAL_PROVIDER) {
	allocate_ops_v1(src_ops, desc->pd_ops_vector, &mech_list_count);
	if (info->pi_interface_version >= CRYPTO_SPI_VERSION_2)
	allocate_ops_v2(src_ops, desc->pd_ops_vector);
	if (info->pi_interface_version == CRYPTO_SPI_VERSION_3)
	allocate_ops_v3(src_ops, desc->pd_ops_vector);
	}

	desc->pd_mech_list_count = mech_list_count;
	desc->pd_mechanisms = kmem_zalloc(sizeof (crypto_mech_info_t) *
	mech_list_count, KM_SLEEP);
	for (i = 0; i < KCF_OPS_CLASSSIZE; i++)
	for (j = 0; j < KCF_MAXMECHTAB; j++)
	desc->pd_mech_indx[i][j] = KCF_INVALID_INDX;

	desc->pd_prov_id = KCF_PROVID_INVALID;
	desc->pd_state = KCF_PROV_ALLOCATED;

	mutex_init(&desc->pd_lock, NULL, MUTEX_DEFAULT, NULL);
	cv_init(&desc->pd_resume_cv, NULL, CV_DEFAULT, NULL);
	cv_init(&desc->pd_remove_cv, NULL, CV_DEFAULT, NULL);

	return (desc);
	}

	/*
	* Called by KCF_PROV_REFRELE when a provider's reference count drops
	* to zero. We free the descriptor when the last reference is released.
	* However, for software providers, we do not free it when there is an
	* unregister thread waiting. We signal that thread in this case and
	* that thread is responsible for freeing the descriptor.
	*/
	void
	kcf_provider_zero_refcnt(kcf_provider_desc_t *desc)
	{
	mutex_enter(&desc->pd_lock);
	switch (desc->pd_prov_type) {
	case CRYPTO_SW_PROVIDER:
	if (desc->pd_state == KCF_PROV_REMOVED \|\|
	desc->pd_state == KCF_PROV_DISABLED) {
	desc->pd_state = KCF_PROV_FREED;
	cv_broadcast(&desc->pd_remove_cv);
	mutex_exit(&desc->pd_lock);
	break;
	}
	- /* FALLTHRU */
	+ fallthrough;

	case CRYPTO_HW_PROVIDER:
	case CRYPTO_LOGICAL_PROVIDER:
	mutex_exit(&desc->pd_lock);
	kcf_free_provider_desc(desc);
	}
	}

	/*
	* Free a provider descriptor.
	*/
	void
	kcf_free_provider_desc(kcf_provider_desc_t *desc)
	{
	if (desc == NULL)
	return;

	mutex_enter(&prov_tab_mutex);
	if (desc->pd_prov_id != KCF_PROVID_INVALID) {
	/* release the associated providers table entry */
	ASSERT(prov_tab[desc->pd_prov_id] != NULL);
	prov_tab[desc->pd_prov_id] = NULL;
	prov_tab_num--;
	}
	mutex_exit(&prov_tab_mutex);

	/* free the kernel memory associated with the provider descriptor */

	if (desc->pd_description != NULL)
	kmem_free(desc->pd_description,
	CRYPTO_PROVIDER_DESCR_MAX_LEN + 1);

	if (desc->pd_ops_vector != NULL) {

	if (desc->pd_ops_vector->co_control_ops != NULL)
	kmem_free(desc->pd_ops_vector->co_control_ops,
	sizeof (crypto_control_ops_t));

	if (desc->pd_ops_vector->co_digest_ops != NULL)
	kmem_free(desc->pd_ops_vector->co_digest_ops,
	sizeof (crypto_digest_ops_t));

	if (desc->pd_ops_vector->co_cipher_ops != NULL)
	kmem_free(desc->pd_ops_vector->co_cipher_ops,
	sizeof (crypto_cipher_ops_t));

	if (desc->pd_ops_vector->co_mac_ops != NULL)
	kmem_free(desc->pd_ops_vector->co_mac_ops,
	sizeof (crypto_mac_ops_t));

	if (desc->pd_ops_vector->co_sign_ops != NULL)
	kmem_free(desc->pd_ops_vector->co_sign_ops,
	sizeof (crypto_sign_ops_t));

	if (desc->pd_ops_vector->co_verify_ops != NULL)
	kmem_free(desc->pd_ops_vector->co_verify_ops,
	sizeof (crypto_verify_ops_t));

	if (desc->pd_ops_vector->co_dual_ops != NULL)
	kmem_free(desc->pd_ops_vector->co_dual_ops,
	sizeof (crypto_dual_ops_t));

	if (desc->pd_ops_vector->co_dual_cipher_mac_ops != NULL)
	kmem_free(desc->pd_ops_vector->co_dual_cipher_mac_ops,
	sizeof (crypto_dual_cipher_mac_ops_t));

	if (desc->pd_ops_vector->co_random_ops != NULL)
	kmem_free(desc->pd_ops_vector->co_random_ops,
	sizeof (crypto_random_number_ops_t));

	if (desc->pd_ops_vector->co_session_ops != NULL)
	kmem_free(desc->pd_ops_vector->co_session_ops,
	sizeof (crypto_session_ops_t));

	if (desc->pd_ops_vector->co_object_ops != NULL)
	kmem_free(desc->pd_ops_vector->co_object_ops,
	sizeof (crypto_object_ops_t));

	if (desc->pd_ops_vector->co_key_ops != NULL)
	kmem_free(desc->pd_ops_vector->co_key_ops,
	sizeof (crypto_key_ops_t));

	if (desc->pd_ops_vector->co_provider_ops != NULL)
	kmem_free(desc->pd_ops_vector->co_provider_ops,
	sizeof (crypto_provider_management_ops_t));

	if (desc->pd_ops_vector->co_ctx_ops != NULL)
	kmem_free(desc->pd_ops_vector->co_ctx_ops,
	sizeof (crypto_ctx_ops_t));

	if (desc->pd_ops_vector->co_mech_ops != NULL)
	kmem_free(desc->pd_ops_vector->co_mech_ops,
	sizeof (crypto_mech_ops_t));

	if (desc->pd_ops_vector->co_nostore_key_ops != NULL)
	kmem_free(desc->pd_ops_vector->co_nostore_key_ops,
	sizeof (crypto_nostore_key_ops_t));

	kmem_free(desc->pd_ops_vector, sizeof (crypto_ops_t));
	}

	if (desc->pd_mechanisms != NULL)
	/* free the memory associated with the mechanism info's */
	kmem_free(desc->pd_mechanisms, sizeof (crypto_mech_info_t) *
	desc->pd_mech_list_count);

	if (desc->pd_sched_info.ks_taskq != NULL)
	taskq_destroy(desc->pd_sched_info.ks_taskq);

	mutex_destroy(&desc->pd_lock);
	cv_destroy(&desc->pd_resume_cv);
	cv_destroy(&desc->pd_remove_cv);

	kmem_free(desc, sizeof (kcf_provider_desc_t));
	}

	/*
	* Returns an array of hardware and logical provider descriptors,
	* a.k.a the PKCS#11 slot list. A REFHOLD is done on each descriptor
	* before the array is returned. The entire table can be freed by
	* calling kcf_free_provider_tab().
	*/
	int
	kcf_get_slot_list(uint_t count, kcf_provider_desc_t **array,
	boolean_t unverified)
	{
	kcf_provider_desc_t *prov_desc;
	kcf_provider_desc_t **p = NULL;
	char *last;
	uint_t cnt = 0;
	uint_t i, j;
	int rval = CRYPTO_SUCCESS;
	size_t n, final_size;

	/* count the providers */
	mutex_enter(&prov_tab_mutex);
	for (i = 0; i < KCF_MAX_PROVIDERS; i++) {
	if ((prov_desc = prov_tab[i]) != NULL &&
	((prov_desc->pd_prov_type == CRYPTO_HW_PROVIDER &&
	(prov_desc->pd_flags & CRYPTO_HIDE_PROVIDER) == 0) \|\|
	prov_desc->pd_prov_type == CRYPTO_LOGICAL_PROVIDER)) {
	if (KCF_IS_PROV_USABLE(prov_desc) \|\|
	(unverified && KCF_IS_PROV_UNVERIFIED(prov_desc))) {
	cnt++;
	}
	}
	}
	mutex_exit(&prov_tab_mutex);

	if (cnt == 0)
	goto out;

	n = cnt * sizeof (kcf_provider_desc_t *);
	again:
	p = kmem_zalloc(n, KM_SLEEP);

	/* pointer to last entry in the array */
	last = (char *)&p[cnt-1];

	mutex_enter(&prov_tab_mutex);
	/* fill the slot list */
	for (i = 0, j = 0; i < KCF_MAX_PROVIDERS; i++) {
	if ((prov_desc = prov_tab[i]) != NULL &&
	((prov_desc->pd_prov_type == CRYPTO_HW_PROVIDER &&
	(prov_desc->pd_flags & CRYPTO_HIDE_PROVIDER) == 0) \|\|
	prov_desc->pd_prov_type == CRYPTO_LOGICAL_PROVIDER)) {
	if (KCF_IS_PROV_USABLE(prov_desc) \|\|
	(unverified && KCF_IS_PROV_UNVERIFIED(prov_desc))) {
	if ((char *)&p[j] > last) {
	mutex_exit(&prov_tab_mutex);
	kcf_free_provider_tab(cnt, p);
	n = n << 1;
	cnt = cnt << 1;
	goto again;
	}
	p[j++] = prov_desc;
	KCF_PROV_REFHOLD(prov_desc);
	}
	}
	}
	mutex_exit(&prov_tab_mutex);

	final_size = j * sizeof (kcf_provider_desc_t *);
	cnt = j;
	ASSERT(final_size <= n);

	/* check if buffer we allocated is too large */
	if (final_size < n) {
	char *final_buffer = NULL;

	if (final_size > 0) {
	final_buffer = kmem_alloc(final_size, KM_SLEEP);
	bcopy(p, final_buffer, final_size);
	}
	kmem_free(p, n);
	p = (kcf_provider_desc_t **)final_buffer;
	}
	out:
	*count = cnt;
	*array = p;
	return (rval);
	}

	/*
	* Free an array of hardware provider descriptors. A REFRELE
	* is done on each descriptor before the table is freed.
	*/
	void
	kcf_free_provider_tab(uint_t count, kcf_provider_desc_t **array)
	{
	kcf_provider_desc_t *prov_desc;
	int i;

	for (i = 0; i < count; i++) {
	if ((prov_desc = array[i]) != NULL) {
	KCF_PROV_REFRELE(prov_desc);
	}
	}
	kmem_free(array, count * sizeof (kcf_provider_desc_t *));
	}

	/*
	* Returns in the location pointed to by pd a pointer to the descriptor
	* for the software provider for the specified mechanism.
	* The provider descriptor is returned held and it is the caller's
	* responsibility to release it when done. The mechanism entry
	* is returned if the optional argument mep is non NULL.
	*
	* Returns one of the CRYPTO_ * error codes on failure, and
	* CRYPTO_SUCCESS on success.
	*/
	int
	kcf_get_sw_prov(crypto_mech_type_t mech_type, kcf_provider_desc_t **pd,
	kcf_mech_entry_t **mep, boolean_t log_warn)
	{
	kcf_mech_entry_t *me;

	/* get the mechanism entry for this mechanism */
	if (kcf_get_mech_entry(mech_type, &me) != KCF_SUCCESS)
	return (CRYPTO_MECHANISM_INVALID);

	/*
	* Get the software provider for this mechanism.
	* Lock the mech_entry until we grab the 'pd'.
	*/
	mutex_enter(&me->me_mutex);

	if (me->me_sw_prov == NULL \|\|
	(*pd = me->me_sw_prov->pm_prov_desc) == NULL) {
	/* no SW provider for this mechanism */
	if (log_warn)
	cmn_err(CE_WARN, "no SW provider for \"%s\"\n",
	me->me_name);
	mutex_exit(&me->me_mutex);
	return (CRYPTO_MECH_NOT_SUPPORTED);
	}

	KCF_PROV_REFHOLD(*pd);
	mutex_exit(&me->me_mutex);

	if (mep != NULL)
	*mep = me;

	return (CRYPTO_SUCCESS);
	}
	diff --git a/sys/contrib/openzfs/module/icp/io/aes.c b/sys/contrib/openzfs/module/icp/io/aes.c
	index e540af4473f7..c47c7567b900 100644
	--- a/sys/contrib/openzfs/module/icp/io/aes.c
	+++ b/sys/contrib/openzfs/module/icp/io/aes.c
	@@ -1,1457 +1,1457 @@
	/*
	* 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) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
	*/

	/*
	* AES provider for the Kernel Cryptographic Framework (KCF)
	*/

	#include <sys/zfs_context.h>
	#include <sys/crypto/common.h>
	#include <sys/crypto/impl.h>
	#include <sys/crypto/spi.h>
	#include <sys/crypto/icp.h>
	#include <modes/modes.h>
	#include <sys/modctl.h>
	#define _AES_IMPL
	#include <aes/aes_impl.h>
	#include <modes/gcm_impl.h>

	#define CRYPTO_PROVIDER_NAME "aes"

	extern struct mod_ops mod_cryptoops;

	/*
	* Module linkage information for the kernel.
	*/
	static struct modlcrypto modlcrypto = {
	&mod_cryptoops,
	"AES Kernel SW Provider"
	};

	static struct modlinkage modlinkage = {
	MODREV_1, { (void *)&modlcrypto, NULL }
	};

	/*
	* Mechanism info structure passed to KCF during registration.
	*/
	static crypto_mech_info_t aes_mech_info_tab[] = {
	/* AES_ECB */
	{SUN_CKM_AES_ECB, AES_ECB_MECH_INFO_TYPE,
	CRYPTO_FG_ENCRYPT \| CRYPTO_FG_ENCRYPT_ATOMIC \|
	CRYPTO_FG_DECRYPT \| CRYPTO_FG_DECRYPT_ATOMIC,
	AES_MIN_KEY_BYTES, AES_MAX_KEY_BYTES, CRYPTO_KEYSIZE_UNIT_IN_BYTES},
	/* AES_CBC */
	{SUN_CKM_AES_CBC, AES_CBC_MECH_INFO_TYPE,
	CRYPTO_FG_ENCRYPT \| CRYPTO_FG_ENCRYPT_ATOMIC \|
	CRYPTO_FG_DECRYPT \| CRYPTO_FG_DECRYPT_ATOMIC,
	AES_MIN_KEY_BYTES, AES_MAX_KEY_BYTES, CRYPTO_KEYSIZE_UNIT_IN_BYTES},
	/* AES_CTR */
	{SUN_CKM_AES_CTR, AES_CTR_MECH_INFO_TYPE,
	CRYPTO_FG_ENCRYPT \| CRYPTO_FG_ENCRYPT_ATOMIC \|
	CRYPTO_FG_DECRYPT \| CRYPTO_FG_DECRYPT_ATOMIC,
	AES_MIN_KEY_BYTES, AES_MAX_KEY_BYTES, CRYPTO_KEYSIZE_UNIT_IN_BYTES},
	/* AES_CCM */
	{SUN_CKM_AES_CCM, AES_CCM_MECH_INFO_TYPE,
	CRYPTO_FG_ENCRYPT \| CRYPTO_FG_ENCRYPT_ATOMIC \|
	CRYPTO_FG_DECRYPT \| CRYPTO_FG_DECRYPT_ATOMIC,
	AES_MIN_KEY_BYTES, AES_MAX_KEY_BYTES, CRYPTO_KEYSIZE_UNIT_IN_BYTES},
	/* AES_GCM */
	{SUN_CKM_AES_GCM, AES_GCM_MECH_INFO_TYPE,
	CRYPTO_FG_ENCRYPT \| CRYPTO_FG_ENCRYPT_ATOMIC \|
	CRYPTO_FG_DECRYPT \| CRYPTO_FG_DECRYPT_ATOMIC,
	AES_MIN_KEY_BYTES, AES_MAX_KEY_BYTES, CRYPTO_KEYSIZE_UNIT_IN_BYTES},
	/* AES_GMAC */
	{SUN_CKM_AES_GMAC, AES_GMAC_MECH_INFO_TYPE,
	CRYPTO_FG_ENCRYPT \| CRYPTO_FG_ENCRYPT_ATOMIC \|
	CRYPTO_FG_DECRYPT \| CRYPTO_FG_DECRYPT_ATOMIC \|
	CRYPTO_FG_MAC \| CRYPTO_FG_MAC_ATOMIC \|
	CRYPTO_FG_SIGN \| CRYPTO_FG_SIGN_ATOMIC \|
	CRYPTO_FG_VERIFY \| CRYPTO_FG_VERIFY_ATOMIC,
	AES_MIN_KEY_BYTES, AES_MAX_KEY_BYTES, CRYPTO_KEYSIZE_UNIT_IN_BYTES}
	};

	static void aes_provider_status(crypto_provider_handle_t, uint_t *);

	static crypto_control_ops_t aes_control_ops = {
	aes_provider_status
	};

	static int aes_encrypt_init(crypto_ctx_t , crypto_mechanism_t ,
	crypto_key_t *, crypto_spi_ctx_template_t, crypto_req_handle_t);
	static int aes_decrypt_init(crypto_ctx_t , crypto_mechanism_t ,
	crypto_key_t *, crypto_spi_ctx_template_t, crypto_req_handle_t);
	static int aes_common_init(crypto_ctx_t , crypto_mechanism_t ,
	crypto_key_t *, crypto_spi_ctx_template_t, crypto_req_handle_t, boolean_t);
	static int aes_common_init_ctx(aes_ctx_t , crypto_spi_ctx_template_t ,
	crypto_mechanism_t , crypto_key_t , int, boolean_t);
	static int aes_encrypt_final(crypto_ctx_t , crypto_data_t ,
	crypto_req_handle_t);
	static int aes_decrypt_final(crypto_ctx_t , crypto_data_t ,
	crypto_req_handle_t);

	static int aes_encrypt(crypto_ctx_t , crypto_data_t , crypto_data_t *,
	crypto_req_handle_t);
	static int aes_encrypt_update(crypto_ctx_t , crypto_data_t ,
	crypto_data_t *, crypto_req_handle_t);
	static int aes_encrypt_atomic(crypto_provider_handle_t, crypto_session_id_t,
	crypto_mechanism_t , crypto_key_t , crypto_data_t *,
	crypto_data_t *, crypto_spi_ctx_template_t, crypto_req_handle_t);

	static int aes_decrypt(crypto_ctx_t , crypto_data_t , crypto_data_t *,
	crypto_req_handle_t);
	static int aes_decrypt_update(crypto_ctx_t , crypto_data_t ,
	crypto_data_t *, crypto_req_handle_t);
	static int aes_decrypt_atomic(crypto_provider_handle_t, crypto_session_id_t,
	crypto_mechanism_t , crypto_key_t , crypto_data_t *,
	crypto_data_t *, crypto_spi_ctx_template_t, crypto_req_handle_t);

	static crypto_cipher_ops_t aes_cipher_ops = {
	.encrypt_init = aes_encrypt_init,
	.encrypt = aes_encrypt,
	.encrypt_update = aes_encrypt_update,
	.encrypt_final = aes_encrypt_final,
	.encrypt_atomic = aes_encrypt_atomic,
	.decrypt_init = aes_decrypt_init,
	.decrypt = aes_decrypt,
	.decrypt_update = aes_decrypt_update,
	.decrypt_final = aes_decrypt_final,
	.decrypt_atomic = aes_decrypt_atomic
	};

	static int aes_mac_atomic(crypto_provider_handle_t, crypto_session_id_t,
	crypto_mechanism_t , crypto_key_t , crypto_data_t , crypto_data_t ,
	crypto_spi_ctx_template_t, crypto_req_handle_t);
	static int aes_mac_verify_atomic(crypto_provider_handle_t, crypto_session_id_t,
	crypto_mechanism_t , crypto_key_t , crypto_data_t , crypto_data_t ,
	crypto_spi_ctx_template_t, crypto_req_handle_t);

	static crypto_mac_ops_t aes_mac_ops = {
	.mac_init = NULL,
	.mac = NULL,
	.mac_update = NULL,
	.mac_final = NULL,
	.mac_atomic = aes_mac_atomic,
	.mac_verify_atomic = aes_mac_verify_atomic
	};

	static int aes_create_ctx_template(crypto_provider_handle_t,
	crypto_mechanism_t , crypto_key_t , crypto_spi_ctx_template_t *,
	size_t *, crypto_req_handle_t);
	static int aes_free_context(crypto_ctx_t *);

	static crypto_ctx_ops_t aes_ctx_ops = {
	.create_ctx_template = aes_create_ctx_template,
	.free_context = aes_free_context
	};

	static crypto_ops_t aes_crypto_ops = {{{{{
	&aes_control_ops,
	NULL,
	&aes_cipher_ops,
	&aes_mac_ops,
	NULL,
	NULL,
	NULL,
	NULL,
	NULL,
	NULL,
	NULL,
	NULL,
	NULL,
	&aes_ctx_ops
	}}}}};

	static crypto_provider_info_t aes_prov_info = {{{{
	CRYPTO_SPI_VERSION_1,
	"AES Software Provider",
	CRYPTO_SW_PROVIDER,
	NULL,
	&aes_crypto_ops,
	sizeof (aes_mech_info_tab)/sizeof (crypto_mech_info_t),
	aes_mech_info_tab
	}}}};

	static crypto_kcf_provider_handle_t aes_prov_handle = 0;
	static crypto_data_t null_crypto_data = { CRYPTO_DATA_RAW };

	int
	aes_mod_init(void)
	{
	int ret;

	/* Determine the fastest available implementation. */
	aes_impl_init();
	gcm_impl_init();

	if ((ret = mod_install(&modlinkage)) != 0)
	return (ret);

	/* Register with KCF. If the registration fails, remove the module. */
	if (crypto_register_provider(&aes_prov_info, &aes_prov_handle)) {
	(void) mod_remove(&modlinkage);
	return (EACCES);
	}

	return (0);
	}

	int
	aes_mod_fini(void)
	{
	/* Unregister from KCF if module is registered */
	if (aes_prov_handle != 0) {
	if (crypto_unregister_provider(aes_prov_handle))
	return (EBUSY);

	aes_prov_handle = 0;
	}

	return (mod_remove(&modlinkage));
	}

	static int
	aes_check_mech_param(crypto_mechanism_t mechanism, aes_ctx_t *ctx, int kmflag)
	{
	void *p = NULL;
	boolean_t param_required = B_TRUE;
	size_t param_len;
	void (alloc_fun)(int);
	int rv = CRYPTO_SUCCESS;

	switch (mechanism->cm_type) {
	case AES_ECB_MECH_INFO_TYPE:
	param_required = B_FALSE;
	alloc_fun = ecb_alloc_ctx;
	break;
	case AES_CBC_MECH_INFO_TYPE:
	param_len = AES_BLOCK_LEN;
	alloc_fun = cbc_alloc_ctx;
	break;
	case AES_CTR_MECH_INFO_TYPE:
	param_len = sizeof (CK_AES_CTR_PARAMS);
	alloc_fun = ctr_alloc_ctx;
	break;
	case AES_CCM_MECH_INFO_TYPE:
	param_len = sizeof (CK_AES_CCM_PARAMS);
	alloc_fun = ccm_alloc_ctx;
	break;
	case AES_GCM_MECH_INFO_TYPE:
	param_len = sizeof (CK_AES_GCM_PARAMS);
	alloc_fun = gcm_alloc_ctx;
	break;
	case AES_GMAC_MECH_INFO_TYPE:
	param_len = sizeof (CK_AES_GMAC_PARAMS);
	alloc_fun = gmac_alloc_ctx;
	break;
	default:
	rv = CRYPTO_MECHANISM_INVALID;
	return (rv);
	}
	if (param_required && mechanism->cm_param != NULL &&
	mechanism->cm_param_len != param_len) {
	rv = CRYPTO_MECHANISM_PARAM_INVALID;
	}
	if (ctx != NULL) {
	p = (alloc_fun)(kmflag);
	*ctx = p;
	}
	return (rv);
	}

	/*
	* Initialize key schedules for AES
	*/
	static int
	init_keysched(crypto_key_t key, void newbie)
	{
	/*
	* Only keys by value are supported by this module.
	*/
	switch (key->ck_format) {
	case CRYPTO_KEY_RAW:
	if (key->ck_length < AES_MINBITS \|\|
	key->ck_length > AES_MAXBITS) {
	return (CRYPTO_KEY_SIZE_RANGE);
	}

	/* key length must be either 128, 192, or 256 */
	if ((key->ck_length & 63) != 0)
	return (CRYPTO_KEY_SIZE_RANGE);
	break;
	default:
	return (CRYPTO_KEY_TYPE_INCONSISTENT);
	}

	aes_init_keysched(key->ck_data, key->ck_length, newbie);
	return (CRYPTO_SUCCESS);
	}

	/*
	* KCF software provider control entry points.
	*/
	/* ARGSUSED */
	static void
	aes_provider_status(crypto_provider_handle_t provider, uint_t *status)
	{
	*status = CRYPTO_PROVIDER_READY;
	}

	static int
	aes_encrypt_init(crypto_ctx_t ctx, crypto_mechanism_t mechanism,
	crypto_key_t *key, crypto_spi_ctx_template_t template,
	crypto_req_handle_t req)
	{
	return (aes_common_init(ctx, mechanism, key, template, req, B_TRUE));
	}

	static int
	aes_decrypt_init(crypto_ctx_t ctx, crypto_mechanism_t mechanism,
	crypto_key_t *key, crypto_spi_ctx_template_t template,
	crypto_req_handle_t req)
	{
	return (aes_common_init(ctx, mechanism, key, template, req, B_FALSE));
	}



	/*
	* KCF software provider encrypt entry points.
	*/
	static int
	aes_common_init(crypto_ctx_t ctx, crypto_mechanism_t mechanism,
	crypto_key_t *key, crypto_spi_ctx_template_t template,
	crypto_req_handle_t req, boolean_t is_encrypt_init)
	{
	aes_ctx_t *aes_ctx;
	int rv;
	int kmflag;

	/*
	* Only keys by value are supported by this module.
	*/
	if (key->ck_format != CRYPTO_KEY_RAW) {
	return (CRYPTO_KEY_TYPE_INCONSISTENT);
	}

	kmflag = crypto_kmflag(req);
	if ((rv = aes_check_mech_param(mechanism, &aes_ctx, kmflag))
	!= CRYPTO_SUCCESS)
	return (rv);

	rv = aes_common_init_ctx(aes_ctx, template, mechanism, key, kmflag,
	is_encrypt_init);
	if (rv != CRYPTO_SUCCESS) {
	crypto_free_mode_ctx(aes_ctx);
	return (rv);
	}

	ctx->cc_provider_private = aes_ctx;

	return (CRYPTO_SUCCESS);
	}

	static void
	aes_copy_block64(uint8_t in, uint64_t out)
	{
	if (IS_P2ALIGNED(in, sizeof (uint64_t))) {
	/* LINTED: pointer alignment */
	out[0] = (uint64_t )&in[0];
	/* LINTED: pointer alignment */
	out[1] = (uint64_t )&in[8];
	} else {
	uint8_t iv8 = (uint8_t )&out[0];

	AES_COPY_BLOCK(in, iv8);
	}
	}


	static int
	aes_encrypt(crypto_ctx_t ctx, crypto_data_t plaintext,
	crypto_data_t *ciphertext, crypto_req_handle_t req)
	{
	int ret = CRYPTO_FAILED;

	aes_ctx_t *aes_ctx;
	size_t saved_length, saved_offset, length_needed;

	ASSERT(ctx->cc_provider_private != NULL);
	aes_ctx = ctx->cc_provider_private;

	/*
	* For block ciphers, plaintext must be a multiple of AES block size.
	* This test is only valid for ciphers whose blocksize is a power of 2.
	*/
	if (((aes_ctx->ac_flags & (CTR_MODE\|CCM_MODE\|GCM_MODE\|GMAC_MODE))
	== 0) && (plaintext->cd_length & (AES_BLOCK_LEN - 1)) != 0)
	return (CRYPTO_DATA_LEN_RANGE);

	ASSERT(ciphertext != NULL);

	/*
	* We need to just return the length needed to store the output.
	* We should not destroy the context for the following case.
	*/
	switch (aes_ctx->ac_flags & (CCM_MODE\|GCM_MODE\|GMAC_MODE)) {
	case CCM_MODE:
	length_needed = plaintext->cd_length + aes_ctx->ac_mac_len;
	break;
	case GCM_MODE:
	length_needed = plaintext->cd_length + aes_ctx->ac_tag_len;
	break;
	case GMAC_MODE:
	if (plaintext->cd_length != 0)
	return (CRYPTO_ARGUMENTS_BAD);

	length_needed = aes_ctx->ac_tag_len;
	break;
	default:
	length_needed = plaintext->cd_length;
	}

	if (ciphertext->cd_length < length_needed) {
	ciphertext->cd_length = length_needed;
	return (CRYPTO_BUFFER_TOO_SMALL);
	}

	saved_length = ciphertext->cd_length;
	saved_offset = ciphertext->cd_offset;

	/*
	* Do an update on the specified input data.
	*/
	ret = aes_encrypt_update(ctx, plaintext, ciphertext, req);
	if (ret != CRYPTO_SUCCESS) {
	return (ret);
	}

	/*
	* For CCM mode, aes_ccm_encrypt_final() will take care of any
	* left-over unprocessed data, and compute the MAC
	*/
	if (aes_ctx->ac_flags & CCM_MODE) {
	/*
	* ccm_encrypt_final() will compute the MAC and append
	* it to existing ciphertext. So, need to adjust the left over
	* length value accordingly
	*/

	/* order of following 2 lines MUST not be reversed */
	ciphertext->cd_offset = ciphertext->cd_length;
	ciphertext->cd_length = saved_length - ciphertext->cd_length;
	ret = ccm_encrypt_final((ccm_ctx_t *)aes_ctx, ciphertext,
	AES_BLOCK_LEN, aes_encrypt_block, aes_xor_block);
	if (ret != CRYPTO_SUCCESS) {
	return (ret);
	}

	if (plaintext != ciphertext) {
	ciphertext->cd_length =
	ciphertext->cd_offset - saved_offset;
	}
	ciphertext->cd_offset = saved_offset;
	} else if (aes_ctx->ac_flags & (GCM_MODE\|GMAC_MODE)) {
	/*
	* gcm_encrypt_final() will compute the MAC and append
	* it to existing ciphertext. So, need to adjust the left over
	* length value accordingly
	*/

	/* order of following 2 lines MUST not be reversed */
	ciphertext->cd_offset = ciphertext->cd_length;
	ciphertext->cd_length = saved_length - ciphertext->cd_length;
	ret = gcm_encrypt_final((gcm_ctx_t *)aes_ctx, ciphertext,
	AES_BLOCK_LEN, aes_encrypt_block, aes_copy_block,
	aes_xor_block);
	if (ret != CRYPTO_SUCCESS) {
	return (ret);
	}

	if (plaintext != ciphertext) {
	ciphertext->cd_length =
	ciphertext->cd_offset - saved_offset;
	}
	ciphertext->cd_offset = saved_offset;
	}

	ASSERT(aes_ctx->ac_remainder_len == 0);
	(void) aes_free_context(ctx);

	return (ret);
	}


	static int
	aes_decrypt(crypto_ctx_t ctx, crypto_data_t ciphertext,
	crypto_data_t *plaintext, crypto_req_handle_t req)
	{
	int ret = CRYPTO_FAILED;

	aes_ctx_t *aes_ctx;
	off_t saved_offset;
	size_t saved_length, length_needed;

	ASSERT(ctx->cc_provider_private != NULL);
	aes_ctx = ctx->cc_provider_private;

	/*
	* For block ciphers, plaintext must be a multiple of AES block size.
	* This test is only valid for ciphers whose blocksize is a power of 2.
	*/
	if (((aes_ctx->ac_flags & (CTR_MODE\|CCM_MODE\|GCM_MODE\|GMAC_MODE))
	== 0) && (ciphertext->cd_length & (AES_BLOCK_LEN - 1)) != 0) {
	return (CRYPTO_ENCRYPTED_DATA_LEN_RANGE);
	}

	ASSERT(plaintext != NULL);

	/*
	* Return length needed to store the output.
	* Do not destroy context when plaintext buffer is too small.
	*
	* CCM: plaintext is MAC len smaller than cipher text
	* GCM: plaintext is TAG len smaller than cipher text
	* GMAC: plaintext length must be zero
	*/
	switch (aes_ctx->ac_flags & (CCM_MODE\|GCM_MODE\|GMAC_MODE)) {
	case CCM_MODE:
	length_needed = aes_ctx->ac_processed_data_len;
	break;
	case GCM_MODE:
	length_needed = ciphertext->cd_length - aes_ctx->ac_tag_len;
	break;
	case GMAC_MODE:
	if (plaintext->cd_length != 0)
	return (CRYPTO_ARGUMENTS_BAD);

	length_needed = 0;
	break;
	default:
	length_needed = ciphertext->cd_length;
	}

	if (plaintext->cd_length < length_needed) {
	plaintext->cd_length = length_needed;
	return (CRYPTO_BUFFER_TOO_SMALL);
	}

	saved_offset = plaintext->cd_offset;
	saved_length = plaintext->cd_length;

	/*
	* Do an update on the specified input data.
	*/
	ret = aes_decrypt_update(ctx, ciphertext, plaintext, req);
	if (ret != CRYPTO_SUCCESS) {
	goto cleanup;
	}

	if (aes_ctx->ac_flags & CCM_MODE) {
	ASSERT(aes_ctx->ac_processed_data_len == aes_ctx->ac_data_len);
	ASSERT(aes_ctx->ac_processed_mac_len == aes_ctx->ac_mac_len);

	/* order of following 2 lines MUST not be reversed */
	plaintext->cd_offset = plaintext->cd_length;
	plaintext->cd_length = saved_length - plaintext->cd_length;

	ret = ccm_decrypt_final((ccm_ctx_t *)aes_ctx, plaintext,
	AES_BLOCK_LEN, aes_encrypt_block, aes_copy_block,
	aes_xor_block);
	if (ret == CRYPTO_SUCCESS) {
	if (plaintext != ciphertext) {
	plaintext->cd_length =
	plaintext->cd_offset - saved_offset;
	}
	} else {
	plaintext->cd_length = saved_length;
	}

	plaintext->cd_offset = saved_offset;
	} else if (aes_ctx->ac_flags & (GCM_MODE\|GMAC_MODE)) {
	/* order of following 2 lines MUST not be reversed */
	plaintext->cd_offset = plaintext->cd_length;
	plaintext->cd_length = saved_length - plaintext->cd_length;

	ret = gcm_decrypt_final((gcm_ctx_t *)aes_ctx, plaintext,
	AES_BLOCK_LEN, aes_encrypt_block, aes_xor_block);
	if (ret == CRYPTO_SUCCESS) {
	if (plaintext != ciphertext) {
	plaintext->cd_length =
	plaintext->cd_offset - saved_offset;
	}
	} else {
	plaintext->cd_length = saved_length;
	}

	plaintext->cd_offset = saved_offset;
	}

	ASSERT(aes_ctx->ac_remainder_len == 0);

	cleanup:
	(void) aes_free_context(ctx);

	return (ret);
	}


	/* ARGSUSED */
	static int
	aes_encrypt_update(crypto_ctx_t ctx, crypto_data_t plaintext,
	crypto_data_t *ciphertext, crypto_req_handle_t req)
	{
	off_t saved_offset;
	size_t saved_length, out_len;
	int ret = CRYPTO_SUCCESS;
	aes_ctx_t *aes_ctx;

	ASSERT(ctx->cc_provider_private != NULL);
	aes_ctx = ctx->cc_provider_private;

	ASSERT(ciphertext != NULL);

	/* compute number of bytes that will hold the ciphertext */
	out_len = aes_ctx->ac_remainder_len;
	out_len += plaintext->cd_length;
	out_len &= ~(AES_BLOCK_LEN - 1);

	/* return length needed to store the output */
	if (ciphertext->cd_length < out_len) {
	ciphertext->cd_length = out_len;
	return (CRYPTO_BUFFER_TOO_SMALL);
	}

	saved_offset = ciphertext->cd_offset;
	saved_length = ciphertext->cd_length;

	/*
	* Do the AES update on the specified input data.
	*/
	switch (plaintext->cd_format) {
	case CRYPTO_DATA_RAW:
	ret = crypto_update_iov(ctx->cc_provider_private,
	plaintext, ciphertext, aes_encrypt_contiguous_blocks,
	aes_copy_block64);
	break;
	case CRYPTO_DATA_UIO:
	ret = crypto_update_uio(ctx->cc_provider_private,
	plaintext, ciphertext, aes_encrypt_contiguous_blocks,
	aes_copy_block64);
	break;
	default:
	ret = CRYPTO_ARGUMENTS_BAD;
	}

	/*
	* Since AES counter mode is a stream cipher, we call
	* ctr_mode_final() to pick up any remaining bytes.
	* It is an internal function that does not destroy
	* the context like normal final routines.
	*/
	if ((aes_ctx->ac_flags & CTR_MODE) && (aes_ctx->ac_remainder_len > 0)) {
	ret = ctr_mode_final((ctr_ctx_t *)aes_ctx,
	ciphertext, aes_encrypt_block);
	}

	if (ret == CRYPTO_SUCCESS) {
	if (plaintext != ciphertext)
	ciphertext->cd_length =
	ciphertext->cd_offset - saved_offset;
	} else {
	ciphertext->cd_length = saved_length;
	}
	ciphertext->cd_offset = saved_offset;

	return (ret);
	}


	static int
	aes_decrypt_update(crypto_ctx_t ctx, crypto_data_t ciphertext,
	crypto_data_t *plaintext, crypto_req_handle_t req)
	{
	off_t saved_offset;
	size_t saved_length, out_len;
	int ret = CRYPTO_SUCCESS;
	aes_ctx_t *aes_ctx;

	ASSERT(ctx->cc_provider_private != NULL);
	aes_ctx = ctx->cc_provider_private;

	ASSERT(plaintext != NULL);

	/*
	* Compute number of bytes that will hold the plaintext.
	* This is not necessary for CCM, GCM, and GMAC since these
	* mechanisms never return plaintext for update operations.
	*/
	if ((aes_ctx->ac_flags & (CCM_MODE\|GCM_MODE\|GMAC_MODE)) == 0) {
	out_len = aes_ctx->ac_remainder_len;
	out_len += ciphertext->cd_length;
	out_len &= ~(AES_BLOCK_LEN - 1);

	/* return length needed to store the output */
	if (plaintext->cd_length < out_len) {
	plaintext->cd_length = out_len;
	return (CRYPTO_BUFFER_TOO_SMALL);
	}
	}

	saved_offset = plaintext->cd_offset;
	saved_length = plaintext->cd_length;

	if (aes_ctx->ac_flags & (GCM_MODE\|GMAC_MODE))
	gcm_set_kmflag((gcm_ctx_t *)aes_ctx, crypto_kmflag(req));

	/*
	* Do the AES update on the specified input data.
	*/
	switch (ciphertext->cd_format) {
	case CRYPTO_DATA_RAW:
	ret = crypto_update_iov(ctx->cc_provider_private,
	ciphertext, plaintext, aes_decrypt_contiguous_blocks,
	aes_copy_block64);
	break;
	case CRYPTO_DATA_UIO:
	ret = crypto_update_uio(ctx->cc_provider_private,
	ciphertext, plaintext, aes_decrypt_contiguous_blocks,
	aes_copy_block64);
	break;
	default:
	ret = CRYPTO_ARGUMENTS_BAD;
	}

	/*
	* Since AES counter mode is a stream cipher, we call
	* ctr_mode_final() to pick up any remaining bytes.
	* It is an internal function that does not destroy
	* the context like normal final routines.
	*/
	if ((aes_ctx->ac_flags & CTR_MODE) && (aes_ctx->ac_remainder_len > 0)) {
	ret = ctr_mode_final((ctr_ctx_t *)aes_ctx, plaintext,
	aes_encrypt_block);
	if (ret == CRYPTO_DATA_LEN_RANGE)
	ret = CRYPTO_ENCRYPTED_DATA_LEN_RANGE;
	}

	if (ret == CRYPTO_SUCCESS) {
	if (ciphertext != plaintext)
	plaintext->cd_length =
	plaintext->cd_offset - saved_offset;
	} else {
	plaintext->cd_length = saved_length;
	}
	plaintext->cd_offset = saved_offset;


	return (ret);
	}

	/* ARGSUSED */
	static int
	aes_encrypt_final(crypto_ctx_t ctx, crypto_data_t data,
	crypto_req_handle_t req)
	{
	aes_ctx_t *aes_ctx;
	int ret;

	ASSERT(ctx->cc_provider_private != NULL);
	aes_ctx = ctx->cc_provider_private;

	if (data->cd_format != CRYPTO_DATA_RAW &&
	data->cd_format != CRYPTO_DATA_UIO) {
	return (CRYPTO_ARGUMENTS_BAD);
	}

	if (aes_ctx->ac_flags & CTR_MODE) {
	if (aes_ctx->ac_remainder_len > 0) {
	ret = ctr_mode_final((ctr_ctx_t *)aes_ctx, data,
	aes_encrypt_block);
	if (ret != CRYPTO_SUCCESS)
	return (ret);
	}
	} else if (aes_ctx->ac_flags & CCM_MODE) {
	ret = ccm_encrypt_final((ccm_ctx_t *)aes_ctx, data,
	AES_BLOCK_LEN, aes_encrypt_block, aes_xor_block);
	if (ret != CRYPTO_SUCCESS) {
	return (ret);
	}
	} else if (aes_ctx->ac_flags & (GCM_MODE\|GMAC_MODE)) {
	size_t saved_offset = data->cd_offset;

	ret = gcm_encrypt_final((gcm_ctx_t *)aes_ctx, data,
	AES_BLOCK_LEN, aes_encrypt_block, aes_copy_block,
	aes_xor_block);
	if (ret != CRYPTO_SUCCESS) {
	return (ret);
	}
	data->cd_length = data->cd_offset - saved_offset;
	data->cd_offset = saved_offset;
	} else {
	/*
	* There must be no unprocessed plaintext.
	* This happens if the length of the last data is
	* not a multiple of the AES block length.
	*/
	if (aes_ctx->ac_remainder_len > 0) {
	return (CRYPTO_DATA_LEN_RANGE);
	}
	data->cd_length = 0;
	}

	(void) aes_free_context(ctx);

	return (CRYPTO_SUCCESS);
	}

	/* ARGSUSED */
	static int
	aes_decrypt_final(crypto_ctx_t ctx, crypto_data_t data,
	crypto_req_handle_t req)
	{
	aes_ctx_t *aes_ctx;
	int ret;
	off_t saved_offset;
	size_t saved_length;

	ASSERT(ctx->cc_provider_private != NULL);
	aes_ctx = ctx->cc_provider_private;

	if (data->cd_format != CRYPTO_DATA_RAW &&
	data->cd_format != CRYPTO_DATA_UIO) {
	return (CRYPTO_ARGUMENTS_BAD);
	}

	/*
	* There must be no unprocessed ciphertext.
	* This happens if the length of the last ciphertext is
	* not a multiple of the AES block length.
	*/
	if (aes_ctx->ac_remainder_len > 0) {
	if ((aes_ctx->ac_flags & CTR_MODE) == 0)
	return (CRYPTO_ENCRYPTED_DATA_LEN_RANGE);
	else {
	ret = ctr_mode_final((ctr_ctx_t *)aes_ctx, data,
	aes_encrypt_block);
	if (ret == CRYPTO_DATA_LEN_RANGE)
	ret = CRYPTO_ENCRYPTED_DATA_LEN_RANGE;
	if (ret != CRYPTO_SUCCESS)
	return (ret);
	}
	}

	if (aes_ctx->ac_flags & CCM_MODE) {
	/*
	* This is where all the plaintext is returned, make sure
	* the plaintext buffer is big enough
	*/
	size_t pt_len = aes_ctx->ac_data_len;
	if (data->cd_length < pt_len) {
	data->cd_length = pt_len;
	return (CRYPTO_BUFFER_TOO_SMALL);
	}

	ASSERT(aes_ctx->ac_processed_data_len == pt_len);
	ASSERT(aes_ctx->ac_processed_mac_len == aes_ctx->ac_mac_len);
	saved_offset = data->cd_offset;
	saved_length = data->cd_length;
	ret = ccm_decrypt_final((ccm_ctx_t *)aes_ctx, data,
	AES_BLOCK_LEN, aes_encrypt_block, aes_copy_block,
	aes_xor_block);
	if (ret == CRYPTO_SUCCESS) {
	data->cd_length = data->cd_offset - saved_offset;
	} else {
	data->cd_length = saved_length;
	}

	data->cd_offset = saved_offset;
	if (ret != CRYPTO_SUCCESS) {
	return (ret);
	}
	} else if (aes_ctx->ac_flags & (GCM_MODE\|GMAC_MODE)) {
	/*
	* This is where all the plaintext is returned, make sure
	* the plaintext buffer is big enough
	*/
	gcm_ctx_t ctx = (gcm_ctx_t )aes_ctx;
	size_t pt_len = ctx->gcm_processed_data_len - ctx->gcm_tag_len;

	if (data->cd_length < pt_len) {
	data->cd_length = pt_len;
	return (CRYPTO_BUFFER_TOO_SMALL);
	}

	saved_offset = data->cd_offset;
	saved_length = data->cd_length;
	ret = gcm_decrypt_final((gcm_ctx_t *)aes_ctx, data,
	AES_BLOCK_LEN, aes_encrypt_block, aes_xor_block);
	if (ret == CRYPTO_SUCCESS) {
	data->cd_length = data->cd_offset - saved_offset;
	} else {
	data->cd_length = saved_length;
	}

	data->cd_offset = saved_offset;
	if (ret != CRYPTO_SUCCESS) {
	return (ret);
	}
	}


	if ((aes_ctx->ac_flags & (CTR_MODE\|CCM_MODE\|GCM_MODE\|GMAC_MODE)) == 0) {
	data->cd_length = 0;
	}

	(void) aes_free_context(ctx);

	return (CRYPTO_SUCCESS);
	}

	/* ARGSUSED */
	static int
	aes_encrypt_atomic(crypto_provider_handle_t provider,
	crypto_session_id_t session_id, crypto_mechanism_t *mechanism,
	crypto_key_t key, crypto_data_t plaintext, crypto_data_t *ciphertext,
	crypto_spi_ctx_template_t template, crypto_req_handle_t req)
	{
	aes_ctx_t aes_ctx; /* on the stack */
	off_t saved_offset;
	size_t saved_length;
	size_t length_needed;
	int ret;

	ASSERT(ciphertext != NULL);

	/*
	* CTR, CCM, GCM, and GMAC modes do not require that plaintext
	* be a multiple of AES block size.
	*/
	switch (mechanism->cm_type) {
	case AES_CTR_MECH_INFO_TYPE:
	case AES_CCM_MECH_INFO_TYPE:
	case AES_GCM_MECH_INFO_TYPE:
	case AES_GMAC_MECH_INFO_TYPE:
	break;
	default:
	if ((plaintext->cd_length & (AES_BLOCK_LEN - 1)) != 0)
	return (CRYPTO_DATA_LEN_RANGE);
	}

	if ((ret = aes_check_mech_param(mechanism, NULL, 0)) != CRYPTO_SUCCESS)
	return (ret);

	bzero(&aes_ctx, sizeof (aes_ctx_t));

	ret = aes_common_init_ctx(&aes_ctx, template, mechanism, key,
	crypto_kmflag(req), B_TRUE);
	if (ret != CRYPTO_SUCCESS)
	return (ret);

	switch (mechanism->cm_type) {
	case AES_CCM_MECH_INFO_TYPE:
	length_needed = plaintext->cd_length + aes_ctx.ac_mac_len;
	break;
	case AES_GMAC_MECH_INFO_TYPE:
	if (plaintext->cd_length != 0)
	return (CRYPTO_ARGUMENTS_BAD);
	- /* FALLTHRU */
	+ fallthrough;
	case AES_GCM_MECH_INFO_TYPE:
	length_needed = plaintext->cd_length + aes_ctx.ac_tag_len;
	break;
	default:
	length_needed = plaintext->cd_length;
	}

	/* return size of buffer needed to store output */
	if (ciphertext->cd_length < length_needed) {
	ciphertext->cd_length = length_needed;
	ret = CRYPTO_BUFFER_TOO_SMALL;
	goto out;
	}

	saved_offset = ciphertext->cd_offset;
	saved_length = ciphertext->cd_length;

	/*
	* Do an update on the specified input data.
	*/
	switch (plaintext->cd_format) {
	case CRYPTO_DATA_RAW:
	ret = crypto_update_iov(&aes_ctx, plaintext, ciphertext,
	aes_encrypt_contiguous_blocks, aes_copy_block64);
	break;
	case CRYPTO_DATA_UIO:
	ret = crypto_update_uio(&aes_ctx, plaintext, ciphertext,
	aes_encrypt_contiguous_blocks, aes_copy_block64);
	break;
	default:
	ret = CRYPTO_ARGUMENTS_BAD;
	}

	if (ret == CRYPTO_SUCCESS) {
	if (mechanism->cm_type == AES_CCM_MECH_INFO_TYPE) {
	ret = ccm_encrypt_final((ccm_ctx_t *)&aes_ctx,
	ciphertext, AES_BLOCK_LEN, aes_encrypt_block,
	aes_xor_block);
	if (ret != CRYPTO_SUCCESS)
	goto out;
	ASSERT(aes_ctx.ac_remainder_len == 0);
	} else if (mechanism->cm_type == AES_GCM_MECH_INFO_TYPE \|\|
	mechanism->cm_type == AES_GMAC_MECH_INFO_TYPE) {
	ret = gcm_encrypt_final((gcm_ctx_t *)&aes_ctx,
	ciphertext, AES_BLOCK_LEN, aes_encrypt_block,
	aes_copy_block, aes_xor_block);
	if (ret != CRYPTO_SUCCESS)
	goto out;
	ASSERT(aes_ctx.ac_remainder_len == 0);
	} else if (mechanism->cm_type == AES_CTR_MECH_INFO_TYPE) {
	if (aes_ctx.ac_remainder_len > 0) {
	ret = ctr_mode_final((ctr_ctx_t *)&aes_ctx,
	ciphertext, aes_encrypt_block);
	if (ret != CRYPTO_SUCCESS)
	goto out;
	}
	} else {
	ASSERT(aes_ctx.ac_remainder_len == 0);
	}

	if (plaintext != ciphertext) {
	ciphertext->cd_length =
	ciphertext->cd_offset - saved_offset;
	}
	} else {
	ciphertext->cd_length = saved_length;
	}
	ciphertext->cd_offset = saved_offset;

	out:
	if (aes_ctx.ac_flags & PROVIDER_OWNS_KEY_SCHEDULE) {
	bzero(aes_ctx.ac_keysched, aes_ctx.ac_keysched_len);
	kmem_free(aes_ctx.ac_keysched, aes_ctx.ac_keysched_len);
	}
	#ifdef CAN_USE_GCM_ASM
	if (aes_ctx.ac_flags & (GCM_MODE\|GMAC_MODE) &&
	((gcm_ctx_t *)&aes_ctx)->gcm_Htable != NULL) {

	gcm_ctx_t ctx = (gcm_ctx_t )&aes_ctx;

	bzero(ctx->gcm_Htable, ctx->gcm_htab_len);
	kmem_free(ctx->gcm_Htable, ctx->gcm_htab_len);
	}
	#endif

	return (ret);
	}

	/* ARGSUSED */
	static int
	aes_decrypt_atomic(crypto_provider_handle_t provider,
	crypto_session_id_t session_id, crypto_mechanism_t *mechanism,
	crypto_key_t key, crypto_data_t ciphertext, crypto_data_t *plaintext,
	crypto_spi_ctx_template_t template, crypto_req_handle_t req)
	{
	aes_ctx_t aes_ctx; /* on the stack */
	off_t saved_offset;
	size_t saved_length;
	size_t length_needed;
	int ret;

	ASSERT(plaintext != NULL);

	/*
	* CCM, GCM, CTR, and GMAC modes do not require that ciphertext
	* be a multiple of AES block size.
	*/
	switch (mechanism->cm_type) {
	case AES_CTR_MECH_INFO_TYPE:
	case AES_CCM_MECH_INFO_TYPE:
	case AES_GCM_MECH_INFO_TYPE:
	case AES_GMAC_MECH_INFO_TYPE:
	break;
	default:
	if ((ciphertext->cd_length & (AES_BLOCK_LEN - 1)) != 0)
	return (CRYPTO_ENCRYPTED_DATA_LEN_RANGE);
	}

	if ((ret = aes_check_mech_param(mechanism, NULL, 0)) != CRYPTO_SUCCESS)
	return (ret);

	bzero(&aes_ctx, sizeof (aes_ctx_t));

	ret = aes_common_init_ctx(&aes_ctx, template, mechanism, key,
	crypto_kmflag(req), B_FALSE);
	if (ret != CRYPTO_SUCCESS)
	return (ret);

	switch (mechanism->cm_type) {
	case AES_CCM_MECH_INFO_TYPE:
	length_needed = aes_ctx.ac_data_len;
	break;
	case AES_GCM_MECH_INFO_TYPE:
	length_needed = ciphertext->cd_length - aes_ctx.ac_tag_len;
	break;
	case AES_GMAC_MECH_INFO_TYPE:
	if (plaintext->cd_length != 0)
	return (CRYPTO_ARGUMENTS_BAD);
	length_needed = 0;
	break;
	default:
	length_needed = ciphertext->cd_length;
	}

	/* return size of buffer needed to store output */
	if (plaintext->cd_length < length_needed) {
	plaintext->cd_length = length_needed;
	ret = CRYPTO_BUFFER_TOO_SMALL;
	goto out;
	}

	saved_offset = plaintext->cd_offset;
	saved_length = plaintext->cd_length;

	if (mechanism->cm_type == AES_GCM_MECH_INFO_TYPE \|\|
	mechanism->cm_type == AES_GMAC_MECH_INFO_TYPE)
	gcm_set_kmflag((gcm_ctx_t *)&aes_ctx, crypto_kmflag(req));

	/*
	* Do an update on the specified input data.
	*/
	switch (ciphertext->cd_format) {
	case CRYPTO_DATA_RAW:
	ret = crypto_update_iov(&aes_ctx, ciphertext, plaintext,
	aes_decrypt_contiguous_blocks, aes_copy_block64);
	break;
	case CRYPTO_DATA_UIO:
	ret = crypto_update_uio(&aes_ctx, ciphertext, plaintext,
	aes_decrypt_contiguous_blocks, aes_copy_block64);
	break;
	default:
	ret = CRYPTO_ARGUMENTS_BAD;
	}

	if (ret == CRYPTO_SUCCESS) {
	if (mechanism->cm_type == AES_CCM_MECH_INFO_TYPE) {
	ASSERT(aes_ctx.ac_processed_data_len
	== aes_ctx.ac_data_len);
	ASSERT(aes_ctx.ac_processed_mac_len
	== aes_ctx.ac_mac_len);
	ret = ccm_decrypt_final((ccm_ctx_t *)&aes_ctx,
	plaintext, AES_BLOCK_LEN, aes_encrypt_block,
	aes_copy_block, aes_xor_block);
	ASSERT(aes_ctx.ac_remainder_len == 0);
	if ((ret == CRYPTO_SUCCESS) &&
	(ciphertext != plaintext)) {
	plaintext->cd_length =
	plaintext->cd_offset - saved_offset;
	} else {
	plaintext->cd_length = saved_length;
	}
	} else if (mechanism->cm_type == AES_GCM_MECH_INFO_TYPE \|\|
	mechanism->cm_type == AES_GMAC_MECH_INFO_TYPE) {
	ret = gcm_decrypt_final((gcm_ctx_t *)&aes_ctx,
	plaintext, AES_BLOCK_LEN, aes_encrypt_block,
	aes_xor_block);
	ASSERT(aes_ctx.ac_remainder_len == 0);
	if ((ret == CRYPTO_SUCCESS) &&
	(ciphertext != plaintext)) {
	plaintext->cd_length =
	plaintext->cd_offset - saved_offset;
	} else {
	plaintext->cd_length = saved_length;
	}
	} else if (mechanism->cm_type != AES_CTR_MECH_INFO_TYPE) {
	ASSERT(aes_ctx.ac_remainder_len == 0);
	if (ciphertext != plaintext)
	plaintext->cd_length =
	plaintext->cd_offset - saved_offset;
	} else {
	if (aes_ctx.ac_remainder_len > 0) {
	ret = ctr_mode_final((ctr_ctx_t *)&aes_ctx,
	plaintext, aes_encrypt_block);
	if (ret == CRYPTO_DATA_LEN_RANGE)
	ret = CRYPTO_ENCRYPTED_DATA_LEN_RANGE;
	if (ret != CRYPTO_SUCCESS)
	goto out;
	}
	if (ciphertext != plaintext)
	plaintext->cd_length =
	plaintext->cd_offset - saved_offset;
	}
	} else {
	plaintext->cd_length = saved_length;
	}
	plaintext->cd_offset = saved_offset;

	out:
	if (aes_ctx.ac_flags & PROVIDER_OWNS_KEY_SCHEDULE) {
	bzero(aes_ctx.ac_keysched, aes_ctx.ac_keysched_len);
	kmem_free(aes_ctx.ac_keysched, aes_ctx.ac_keysched_len);
	}

	if (aes_ctx.ac_flags & CCM_MODE) {
	if (aes_ctx.ac_pt_buf != NULL) {
	vmem_free(aes_ctx.ac_pt_buf, aes_ctx.ac_data_len);
	}
	} else if (aes_ctx.ac_flags & (GCM_MODE\|GMAC_MODE)) {
	if (((gcm_ctx_t *)&aes_ctx)->gcm_pt_buf != NULL) {
	vmem_free(((gcm_ctx_t *)&aes_ctx)->gcm_pt_buf,
	((gcm_ctx_t *)&aes_ctx)->gcm_pt_buf_len);
	}
	#ifdef CAN_USE_GCM_ASM
	if (((gcm_ctx_t *)&aes_ctx)->gcm_Htable != NULL) {
	gcm_ctx_t ctx = (gcm_ctx_t )&aes_ctx;

	bzero(ctx->gcm_Htable, ctx->gcm_htab_len);
	kmem_free(ctx->gcm_Htable, ctx->gcm_htab_len);
	}
	#endif
	}

	return (ret);
	}

	/*
	* KCF software provider context template entry points.
	*/
	/* ARGSUSED */
	static int
	aes_create_ctx_template(crypto_provider_handle_t provider,
	crypto_mechanism_t mechanism, crypto_key_t key,
	crypto_spi_ctx_template_t tmpl, size_t tmpl_size, crypto_req_handle_t req)
	{
	void *keysched;
	size_t size;
	int rv;

	if (mechanism->cm_type != AES_ECB_MECH_INFO_TYPE &&
	mechanism->cm_type != AES_CBC_MECH_INFO_TYPE &&
	mechanism->cm_type != AES_CTR_MECH_INFO_TYPE &&
	mechanism->cm_type != AES_CCM_MECH_INFO_TYPE &&
	mechanism->cm_type != AES_GCM_MECH_INFO_TYPE &&
	mechanism->cm_type != AES_GMAC_MECH_INFO_TYPE)
	return (CRYPTO_MECHANISM_INVALID);

	if ((keysched = aes_alloc_keysched(&size,
	crypto_kmflag(req))) == NULL) {
	return (CRYPTO_HOST_MEMORY);
	}

	/*
	* Initialize key schedule. Key length information is stored
	* in the key.
	*/
	if ((rv = init_keysched(key, keysched)) != CRYPTO_SUCCESS) {
	bzero(keysched, size);
	kmem_free(keysched, size);
	return (rv);
	}

	*tmpl = keysched;
	*tmpl_size = size;

	return (CRYPTO_SUCCESS);
	}


	static int
	aes_free_context(crypto_ctx_t *ctx)
	{
	aes_ctx_t *aes_ctx = ctx->cc_provider_private;

	if (aes_ctx != NULL) {
	if (aes_ctx->ac_flags & PROVIDER_OWNS_KEY_SCHEDULE) {
	ASSERT(aes_ctx->ac_keysched_len != 0);
	bzero(aes_ctx->ac_keysched, aes_ctx->ac_keysched_len);
	kmem_free(aes_ctx->ac_keysched,
	aes_ctx->ac_keysched_len);
	}
	crypto_free_mode_ctx(aes_ctx);
	ctx->cc_provider_private = NULL;
	}

	return (CRYPTO_SUCCESS);
	}


	static int
	aes_common_init_ctx(aes_ctx_t aes_ctx, crypto_spi_ctx_template_t template,
	crypto_mechanism_t mechanism, crypto_key_t key, int kmflag,
	boolean_t is_encrypt_init)
	{
	int rv = CRYPTO_SUCCESS;
	void *keysched;
	size_t size = 0;

	if (template == NULL) {
	if ((keysched = aes_alloc_keysched(&size, kmflag)) == NULL)
	return (CRYPTO_HOST_MEMORY);
	/*
	* Initialize key schedule.
	* Key length is stored in the key.
	*/
	if ((rv = init_keysched(key, keysched)) != CRYPTO_SUCCESS) {
	kmem_free(keysched, size);
	return (rv);
	}

	aes_ctx->ac_flags \|= PROVIDER_OWNS_KEY_SCHEDULE;
	aes_ctx->ac_keysched_len = size;
	} else {
	keysched = template;
	}
	aes_ctx->ac_keysched = keysched;

	switch (mechanism->cm_type) {
	case AES_CBC_MECH_INFO_TYPE:
	rv = cbc_init_ctx((cbc_ctx_t *)aes_ctx, mechanism->cm_param,
	mechanism->cm_param_len, AES_BLOCK_LEN, aes_copy_block64);
	break;
	case AES_CTR_MECH_INFO_TYPE: {
	CK_AES_CTR_PARAMS *pp;

	if (mechanism->cm_param == NULL \|\|
	mechanism->cm_param_len != sizeof (CK_AES_CTR_PARAMS)) {
	return (CRYPTO_MECHANISM_PARAM_INVALID);
	}
	pp = (CK_AES_CTR_PARAMS )(void )mechanism->cm_param;
	rv = ctr_init_ctx((ctr_ctx_t *)aes_ctx, pp->ulCounterBits,
	pp->cb, aes_copy_block);
	break;
	}
	case AES_CCM_MECH_INFO_TYPE:
	if (mechanism->cm_param == NULL \|\|
	mechanism->cm_param_len != sizeof (CK_AES_CCM_PARAMS)) {
	return (CRYPTO_MECHANISM_PARAM_INVALID);
	}
	rv = ccm_init_ctx((ccm_ctx_t *)aes_ctx, mechanism->cm_param,
	kmflag, is_encrypt_init, AES_BLOCK_LEN, aes_encrypt_block,
	aes_xor_block);
	break;
	case AES_GCM_MECH_INFO_TYPE:
	if (mechanism->cm_param == NULL \|\|
	mechanism->cm_param_len != sizeof (CK_AES_GCM_PARAMS)) {
	return (CRYPTO_MECHANISM_PARAM_INVALID);
	}
	rv = gcm_init_ctx((gcm_ctx_t *)aes_ctx, mechanism->cm_param,
	AES_BLOCK_LEN, aes_encrypt_block, aes_copy_block,
	aes_xor_block);
	break;
	case AES_GMAC_MECH_INFO_TYPE:
	if (mechanism->cm_param == NULL \|\|
	mechanism->cm_param_len != sizeof (CK_AES_GMAC_PARAMS)) {
	return (CRYPTO_MECHANISM_PARAM_INVALID);
	}
	rv = gmac_init_ctx((gcm_ctx_t *)aes_ctx, mechanism->cm_param,
	AES_BLOCK_LEN, aes_encrypt_block, aes_copy_block,
	aes_xor_block);
	break;
	case AES_ECB_MECH_INFO_TYPE:
	aes_ctx->ac_flags \|= ECB_MODE;
	}

	if (rv != CRYPTO_SUCCESS) {
	if (aes_ctx->ac_flags & PROVIDER_OWNS_KEY_SCHEDULE) {
	bzero(keysched, size);
	kmem_free(keysched, size);
	}
	}

	return (rv);
	}

	static int
	process_gmac_mech(crypto_mechanism_t mech, crypto_data_t data,
	CK_AES_GCM_PARAMS *gcm_params)
	{
	/* LINTED: pointer alignment */
	CK_AES_GMAC_PARAMS params = (CK_AES_GMAC_PARAMS )mech->cm_param;

	if (mech->cm_type != AES_GMAC_MECH_INFO_TYPE)
	return (CRYPTO_MECHANISM_INVALID);

	if (mech->cm_param_len != sizeof (CK_AES_GMAC_PARAMS))
	return (CRYPTO_MECHANISM_PARAM_INVALID);

	if (params->pIv == NULL)
	return (CRYPTO_MECHANISM_PARAM_INVALID);

	gcm_params->pIv = params->pIv;
	gcm_params->ulIvLen = AES_GMAC_IV_LEN;
	gcm_params->ulTagBits = AES_GMAC_TAG_BITS;

	if (data == NULL)
	return (CRYPTO_SUCCESS);

	if (data->cd_format != CRYPTO_DATA_RAW)
	return (CRYPTO_ARGUMENTS_BAD);

	gcm_params->pAAD = (uchar_t *)data->cd_raw.iov_base;
	gcm_params->ulAADLen = data->cd_length;
	return (CRYPTO_SUCCESS);
	}

	static int
	aes_mac_atomic(crypto_provider_handle_t provider,
	crypto_session_id_t session_id, crypto_mechanism_t *mechanism,
	crypto_key_t key, crypto_data_t data, crypto_data_t *mac,
	crypto_spi_ctx_template_t template, crypto_req_handle_t req)
	{
	CK_AES_GCM_PARAMS gcm_params;
	crypto_mechanism_t gcm_mech;
	int rv;

	if ((rv = process_gmac_mech(mechanism, data, &gcm_params))
	!= CRYPTO_SUCCESS)
	return (rv);

	gcm_mech.cm_type = AES_GCM_MECH_INFO_TYPE;
	gcm_mech.cm_param_len = sizeof (CK_AES_GCM_PARAMS);
	gcm_mech.cm_param = (char *)&gcm_params;

	return (aes_encrypt_atomic(provider, session_id, &gcm_mech,
	key, &null_crypto_data, mac, template, req));
	}

	static int
	aes_mac_verify_atomic(crypto_provider_handle_t provider,
	crypto_session_id_t session_id, crypto_mechanism_t *mechanism,
	crypto_key_t key, crypto_data_t data, crypto_data_t *mac,
	crypto_spi_ctx_template_t template, crypto_req_handle_t req)
	{
	CK_AES_GCM_PARAMS gcm_params;
	crypto_mechanism_t gcm_mech;
	int rv;

	if ((rv = process_gmac_mech(mechanism, data, &gcm_params))
	!= CRYPTO_SUCCESS)
	return (rv);

	gcm_mech.cm_type = AES_GCM_MECH_INFO_TYPE;
	gcm_mech.cm_param_len = sizeof (CK_AES_GCM_PARAMS);
	gcm_mech.cm_param = (char *)&gcm_params;

	return (aes_decrypt_atomic(provider, session_id, &gcm_mech,
	key, mac, &null_crypto_data, template, req));
	}
	diff --git a/sys/contrib/openzfs/module/lua/lcode.c b/sys/contrib/openzfs/module/lua/lcode.c
	index ae9a3d91d810..4d88c792a281 100644
	--- a/sys/contrib/openzfs/module/lua/lcode.c
	+++ b/sys/contrib/openzfs/module/lua/lcode.c
	@@ -1,884 +1,888 @@
	/* BEGIN CSTYLED */
	/*
	** $Id: lcode.c,v 2.62.1.1 2013/04/12 18:48:47 roberto Exp $
	** Code generator for Lua
	** See Copyright Notice in lua.h
	*/

	#define lcode_c
	#define LUA_CORE

	+#if defined(HAVE_IMPLICIT_FALLTHROUGH)
	+#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
	+#endif
	+
	#include <sys/lua/lua.h>

	#include "lcode.h"
	#include "ldebug.h"
	#include "ldo.h"
	#include "lgc.h"
	#include "llex.h"
	#include "lmem.h"
	#include "lobject.h"
	#include "lopcodes.h"
	#include "lparser.h"
	#include "lstring.h"
	#include "ltable.h"
	#include "lvm.h"


	#define hasjumps(e) ((e)->t != (e)->f)


	static int isnumeral(expdesc *e) {
	return (e->k == VKNUM && e->t == NO_JUMP && e->f == NO_JUMP);
	}


	void luaK_nil (FuncState *fs, int from, int n) {
	Instruction *previous;
	int l = from + n - 1; /* last register to set nil */
	if (fs->pc > fs->lasttarget) { /* no jumps to current position? */
	previous = &fs->f->code[fs->pc-1];
	if (GET_OPCODE(*previous) == OP_LOADNIL) {
	int pfrom = GETARG_A(*previous);
	int pl = pfrom + GETARG_B(*previous);
	if ((pfrom <= from && from <= pl + 1) \|\|
	(from <= pfrom && pfrom <= l + 1)) { /* can connect both? */
	if (pfrom < from) from = pfrom; /* from = min(from, pfrom) */
	if (pl > l) l = pl; /* l = max(l, pl) */
	SETARG_A(*previous, from);
	SETARG_B(*previous, l - from);
	return;
	}
	} /* else go through */
	}
	luaK_codeABC(fs, OP_LOADNIL, from, n - 1, 0); /* else no optimization */
	}


	int luaK_jump (FuncState *fs) {
	int jpc = fs->jpc; /* save list of jumps to here */
	int j;
	fs->jpc = NO_JUMP;
	j = luaK_codeAsBx(fs, OP_JMP, 0, NO_JUMP);
	luaK_concat(fs, &j, jpc); /* keep them on hold */
	return j;
	}


	void luaK_ret (FuncState *fs, int first, int nret) {
	luaK_codeABC(fs, OP_RETURN, first, nret+1, 0);
	}


	static int condjump (FuncState *fs, OpCode op, int A, int B, int C) {
	luaK_codeABC(fs, op, A, B, C);
	return luaK_jump(fs);
	}


	static void fixjump (FuncState *fs, int pc, int dest) {
	Instruction *jmp = &fs->f->code[pc];
	int offset = dest-(pc+1);
	lua_assert(dest != NO_JUMP);
	if (abs(offset) > MAXARG_sBx)
	luaX_syntaxerror(fs->ls, "control structure too long");
	SETARG_sBx(*jmp, offset);
	}


	/*
	** returns current `pc' and marks it as a jump target (to avoid wrong
	** optimizations with consecutive instructions not in the same basic block).
	*/
	int luaK_getlabel (FuncState *fs) {
	fs->lasttarget = fs->pc;
	return fs->pc;
	}


	static int getjump (FuncState *fs, int pc) {
	int offset = GETARG_sBx(fs->f->code[pc]);
	if (offset == NO_JUMP) /* point to itself represents end of list */
	return NO_JUMP; /* end of list */
	else
	return (pc+1)+offset; /* turn offset into absolute position */
	}


	static Instruction getjumpcontrol (FuncState fs, int pc) {
	Instruction *pi = &fs->f->code[pc];
	if (pc >= 1 && testTMode(GET_OPCODE(*(pi-1))))
	return pi-1;
	else
	return pi;
	}


	/*
	** check whether list has any jump that do not produce a value
	** (or produce an inverted value)
	*/
	static int need_value (FuncState *fs, int list) {
	for (; list != NO_JUMP; list = getjump(fs, list)) {
	Instruction i = *getjumpcontrol(fs, list);
	if (GET_OPCODE(i) != OP_TESTSET) return 1;
	}
	return 0; /* not found */
	}


	static int patchtestreg (FuncState *fs, int node, int reg) {
	Instruction *i = getjumpcontrol(fs, node);
	if (GET_OPCODE(*i) != OP_TESTSET)
	return 0; /* cannot patch other instructions */
	if (reg != NO_REG && reg != GETARG_B(*i))
	SETARG_A(*i, reg);
	else /* no register to put value or register already has the value */
	i = CREATE_ABC(OP_TEST, GETARG_B(i), 0, GETARG_C(*i));

	return 1;
	}


	static void removevalues (FuncState *fs, int list) {
	for (; list != NO_JUMP; list = getjump(fs, list))
	patchtestreg(fs, list, NO_REG);
	}


	static void patchlistaux (FuncState *fs, int list, int vtarget, int reg,
	int dtarget) {
	while (list != NO_JUMP) {
	int next = getjump(fs, list);
	if (patchtestreg(fs, list, reg))
	fixjump(fs, list, vtarget);
	else
	fixjump(fs, list, dtarget); /* jump to default target */
	list = next;
	}
	}


	static void dischargejpc (FuncState *fs) {
	patchlistaux(fs, fs->jpc, fs->pc, NO_REG, fs->pc);
	fs->jpc = NO_JUMP;
	}


	void luaK_patchlist (FuncState *fs, int list, int target) {
	if (target == fs->pc)
	luaK_patchtohere(fs, list);
	else {
	lua_assert(target < fs->pc);
	patchlistaux(fs, list, target, NO_REG, target);
	}
	}


	LUAI_FUNC void luaK_patchclose (FuncState *fs, int list, int level) {
	level++; /* argument is +1 to reserve 0 as non-op */
	while (list != NO_JUMP) {
	int next = getjump(fs, list);
	lua_assert(GET_OPCODE(fs->f->code[list]) == OP_JMP &&
	(GETARG_A(fs->f->code[list]) == 0 \|\|
	GETARG_A(fs->f->code[list]) >= level));
	SETARG_A(fs->f->code[list], level);
	list = next;
	}
	}


	void luaK_patchtohere (FuncState *fs, int list) {
	luaK_getlabel(fs);
	luaK_concat(fs, &fs->jpc, list);
	}


	void luaK_concat (FuncState fs, int l1, int l2) {
	if (l2 == NO_JUMP) return;
	else if (*l1 == NO_JUMP)
	*l1 = l2;
	else {
	int list = *l1;
	int next;
	while ((next = getjump(fs, list)) != NO_JUMP) /* find last element */
	list = next;
	fixjump(fs, list, l2);
	}
	}


	static int luaK_code (FuncState *fs, Instruction i) {
	Proto *f = fs->f;
	dischargejpc(fs); /* `pc' will change */
	/* put new instruction in code array */
	luaM_growvector(fs->ls->L, f->code, fs->pc, f->sizecode, Instruction,
	MAX_INT, "opcodes");
	f->code[fs->pc] = i;
	/* save corresponding line information */
	luaM_growvector(fs->ls->L, f->lineinfo, fs->pc, f->sizelineinfo, int,
	MAX_INT, "opcodes");
	f->lineinfo[fs->pc] = fs->ls->lastline;
	return fs->pc++;
	}


	int luaK_codeABC (FuncState *fs, OpCode o, int a, int b, int c) {
	lua_assert(getOpMode(o) == iABC);
	lua_assert(getBMode(o) != OpArgN \|\| b == 0);
	lua_assert(getCMode(o) != OpArgN \|\| c == 0);
	lua_assert(a <= MAXARG_A && b <= MAXARG_B && c <= MAXARG_C);
	return luaK_code(fs, CREATE_ABC(o, a, b, c));
	}


	int luaK_codeABx (FuncState *fs, OpCode o, int a, unsigned int bc) {
	lua_assert(getOpMode(o) == iABx \|\| getOpMode(o) == iAsBx);
	lua_assert(getCMode(o) == OpArgN);
	lua_assert(a <= MAXARG_A && bc <= MAXARG_Bx);
	return luaK_code(fs, CREATE_ABx(o, a, bc));
	}


	static int codeextraarg (FuncState *fs, int a) {
	lua_assert(a <= MAXARG_Ax);
	return luaK_code(fs, CREATE_Ax(OP_EXTRAARG, a));
	}


	int luaK_codek (FuncState *fs, int reg, int k) {
	if (k <= MAXARG_Bx)
	return luaK_codeABx(fs, OP_LOADK, reg, k);
	else {
	int p = luaK_codeABx(fs, OP_LOADKX, reg, 0);
	codeextraarg(fs, k);
	return p;
	}
	}


	void luaK_checkstack (FuncState *fs, int n) {
	int newstack = fs->freereg + n;
	if (newstack > fs->f->maxstacksize) {
	if (newstack >= MAXSTACK)
	luaX_syntaxerror(fs->ls, "function or expression too complex");
	fs->f->maxstacksize = cast_byte(newstack);
	}
	}


	void luaK_reserveregs (FuncState *fs, int n) {
	luaK_checkstack(fs, n);
	fs->freereg += n;
	}


	static void freereg (FuncState *fs, int reg) {
	if (!ISK(reg) && reg >= fs->nactvar) {
	fs->freereg--;
	lua_assert(reg == fs->freereg);
	}
	}


	static void freeexp (FuncState fs, expdesc e) {
	if (e->k == VNONRELOC)
	freereg(fs, e->u.info);
	}


	static int addk (FuncState fs, TValue key, TValue *v) {
	lua_State *L = fs->ls->L;
	TValue *idx = luaH_set(L, fs->h, key);
	Proto *f = fs->f;
	int k, oldsize;
	if (ttisnumber(idx)) {
	lua_Number n = nvalue(idx);
	lua_number2int(k, n);
	if (luaV_rawequalobj(&f->k[k], v))
	return k;
	/* else may be a collision (e.g., between 0.0 and "\0\0\0\0\0\0\0\0");
	go through and create a new entry for this value */
	}
	/* constant not found; create a new entry */
	oldsize = f->sizek;
	k = fs->nk;
	/* numerical value does not need GC barrier;
	table has no metatable, so it does not need to invalidate cache */
	setnvalue(idx, cast_num(k));
	luaM_growvector(L, f->k, k, f->sizek, TValue, MAXARG_Ax, "constants");
	while (oldsize < f->sizek) setnilvalue(&f->k[oldsize++]);
	setobj(L, &f->k[k], v);
	fs->nk++;
	luaC_barrier(L, f, v);
	return k;
	}


	int luaK_stringK (FuncState fs, TString s) {
	TValue o;
	setsvalue(fs->ls->L, &o, s);
	return addk(fs, &o, &o);
	}


	int luaK_numberK (FuncState *fs, lua_Number r) {
	int n;
	lua_State *L = fs->ls->L;
	TValue o;
	setnvalue(&o, r);
	if (r == 0 \|\| luai_numisnan(NULL, r)) { /* handle -0 and NaN */
	/* use raw representation as key to avoid numeric problems */
	setsvalue(L, L->top++, luaS_newlstr(L, (char *)&r, sizeof(r)));
	n = addk(fs, L->top - 1, &o);
	L->top--;
	}
	else
	n = addk(fs, &o, &o); /* regular case */
	return n;
	}


	static int boolK (FuncState *fs, int b) {
	TValue o;
	setbvalue(&o, b);
	return addk(fs, &o, &o);
	}


	static int nilK (FuncState *fs) {
	TValue k, v;
	setnilvalue(&v);
	/* cannot use nil as key; instead use table itself to represent nil */
	sethvalue(fs->ls->L, &k, fs->h);
	return addk(fs, &k, &v);
	}


	void luaK_setreturns (FuncState fs, expdesc e, int nresults) {
	if (e->k == VCALL) { /* expression is an open function call? */
	SETARG_C(getcode(fs, e), nresults+1);
	}
	else if (e->k == VVARARG) {
	SETARG_B(getcode(fs, e), nresults+1);
	SETARG_A(getcode(fs, e), fs->freereg);
	luaK_reserveregs(fs, 1);
	}
	}


	void luaK_setoneret (FuncState fs, expdesc e) {
	if (e->k == VCALL) { /* expression is an open function call? */
	e->k = VNONRELOC;
	e->u.info = GETARG_A(getcode(fs, e));
	}
	else if (e->k == VVARARG) {
	SETARG_B(getcode(fs, e), 2);
	e->k = VRELOCABLE; /* can relocate its simple result */
	}
	}


	void luaK_dischargevars (FuncState fs, expdesc e) {
	switch (e->k) {
	case VLOCAL: {
	e->k = VNONRELOC;
	break;
	}
	case VUPVAL: {
	e->u.info = luaK_codeABC(fs, OP_GETUPVAL, 0, e->u.info, 0);
	e->k = VRELOCABLE;
	break;
	}
	case VINDEXED: {
	OpCode op = OP_GETTABUP; /* assume 't' is in an upvalue */
	freereg(fs, e->u.ind.idx);
	if (e->u.ind.vt == VLOCAL) { /* 't' is in a register? */
	freereg(fs, e->u.ind.t);
	op = OP_GETTABLE;
	}
	e->u.info = luaK_codeABC(fs, op, 0, e->u.ind.t, e->u.ind.idx);
	e->k = VRELOCABLE;
	break;
	}
	case VVARARG:
	case VCALL: {
	luaK_setoneret(fs, e);
	break;
	}
	default: break; /* there is one value available (somewhere) */
	}
	}


	static int code_label (FuncState *fs, int A, int b, int jump) {
	luaK_getlabel(fs); /* those instructions may be jump targets */
	return luaK_codeABC(fs, OP_LOADBOOL, A, b, jump);
	}


	static void discharge2reg (FuncState fs, expdesc e, int reg) {
	luaK_dischargevars(fs, e);
	switch (e->k) {
	case VNIL: {
	luaK_nil(fs, reg, 1);
	break;
	}
	case VFALSE: case VTRUE: {
	luaK_codeABC(fs, OP_LOADBOOL, reg, e->k == VTRUE, 0);
	break;
	}
	case VK: {
	luaK_codek(fs, reg, e->u.info);
	break;
	}
	case VKNUM: {
	luaK_codek(fs, reg, luaK_numberK(fs, e->u.nval));
	break;
	}
	case VRELOCABLE: {
	Instruction *pc = &getcode(fs, e);
	SETARG_A(*pc, reg);
	break;
	}
	case VNONRELOC: {
	if (reg != e->u.info)
	luaK_codeABC(fs, OP_MOVE, reg, e->u.info, 0);
	break;
	}
	default: {
	lua_assert(e->k == VVOID \|\| e->k == VJMP);
	return; /* nothing to do... */
	}
	}
	e->u.info = reg;
	e->k = VNONRELOC;
	}


	static void discharge2anyreg (FuncState fs, expdesc e) {
	if (e->k != VNONRELOC) {
	luaK_reserveregs(fs, 1);
	discharge2reg(fs, e, fs->freereg-1);
	}
	}


	static void exp2reg (FuncState fs, expdesc e, int reg) {
	discharge2reg(fs, e, reg);
	if (e->k == VJMP)
	luaK_concat(fs, &e->t, e->u.info); /* put this jump in `t' list */
	if (hasjumps(e)) {
	int final; /* position after whole expression */
	int p_f = NO_JUMP; /* position of an eventual LOAD false */
	int p_t = NO_JUMP; /* position of an eventual LOAD true */
	if (need_value(fs, e->t) \|\| need_value(fs, e->f)) {
	int fj = (e->k == VJMP) ? NO_JUMP : luaK_jump(fs);
	p_f = code_label(fs, reg, 0, 1);
	p_t = code_label(fs, reg, 1, 0);
	luaK_patchtohere(fs, fj);
	}
	final = luaK_getlabel(fs);
	patchlistaux(fs, e->f, final, reg, p_f);
	patchlistaux(fs, e->t, final, reg, p_t);
	}
	e->f = e->t = NO_JUMP;
	e->u.info = reg;
	e->k = VNONRELOC;
	}


	void luaK_exp2nextreg (FuncState fs, expdesc e) {
	luaK_dischargevars(fs, e);
	freeexp(fs, e);
	luaK_reserveregs(fs, 1);
	exp2reg(fs, e, fs->freereg - 1);
	}


	int luaK_exp2anyreg (FuncState fs, expdesc e) {
	luaK_dischargevars(fs, e);
	if (e->k == VNONRELOC) {
	if (!hasjumps(e)) return e->u.info; /* exp is already in a register */
	if (e->u.info >= fs->nactvar) { /* reg. is not a local? */
	exp2reg(fs, e, e->u.info); /* put value on it */
	return e->u.info;
	}
	}
	luaK_exp2nextreg(fs, e); /* default */
	return e->u.info;
	}


	void luaK_exp2anyregup (FuncState fs, expdesc e) {
	if (e->k != VUPVAL \|\| hasjumps(e))
	luaK_exp2anyreg(fs, e);
	}


	void luaK_exp2val (FuncState fs, expdesc e) {
	if (hasjumps(e))
	luaK_exp2anyreg(fs, e);
	else
	luaK_dischargevars(fs, e);
	}


	int luaK_exp2RK (FuncState fs, expdesc e) {
	luaK_exp2val(fs, e);
	switch (e->k) {
	case VTRUE:
	case VFALSE:
	case VNIL: {
	if (fs->nk <= MAXINDEXRK) { /* constant fits in RK operand? */
	e->u.info = (e->k == VNIL) ? nilK(fs) : boolK(fs, (e->k == VTRUE));
	e->k = VK;
	return RKASK(e->u.info);
	}
	else break;
	}
	case VKNUM: {
	e->u.info = luaK_numberK(fs, e->u.nval);
	e->k = VK;
	/* go through */
	}
	case VK: {
	if (e->u.info <= MAXINDEXRK) /* constant fits in argC? */
	return RKASK(e->u.info);
	else break;
	}
	default: break;
	}
	/* not a constant in the right range: put it in a register */
	return luaK_exp2anyreg(fs, e);
	}


	void luaK_storevar (FuncState fs, expdesc var, expdesc *ex) {
	switch (var->k) {
	case VLOCAL: {
	freeexp(fs, ex);
	exp2reg(fs, ex, var->u.info);
	return;
	}
	case VUPVAL: {
	int e = luaK_exp2anyreg(fs, ex);
	luaK_codeABC(fs, OP_SETUPVAL, e, var->u.info, 0);
	break;
	}
	case VINDEXED: {
	OpCode op = (var->u.ind.vt == VLOCAL) ? OP_SETTABLE : OP_SETTABUP;
	int e = luaK_exp2RK(fs, ex);
	luaK_codeABC(fs, op, var->u.ind.t, var->u.ind.idx, e);
	break;
	}
	default: {
	lua_assert(0); /* invalid var kind to store */
	break;
	}
	}
	freeexp(fs, ex);
	}


	void luaK_self (FuncState fs, expdesc e, expdesc *key) {
	int ereg;
	luaK_exp2anyreg(fs, e);
	ereg = e->u.info; /* register where 'e' was placed */
	freeexp(fs, e);
	e->u.info = fs->freereg; /* base register for op_self */
	e->k = VNONRELOC;
	luaK_reserveregs(fs, 2); /* function and 'self' produced by op_self */
	luaK_codeABC(fs, OP_SELF, e->u.info, ereg, luaK_exp2RK(fs, key));
	freeexp(fs, key);
	}


	static void invertjump (FuncState fs, expdesc e) {
	Instruction *pc = getjumpcontrol(fs, e->u.info);
	lua_assert(testTMode(GET_OPCODE(pc)) && GET_OPCODE(pc) != OP_TESTSET &&
	GET_OPCODE(*pc) != OP_TEST);
	SETARG_A(pc, !(GETARG_A(pc)));
	}


	static int jumponcond (FuncState fs, expdesc e, int cond) {
	if (e->k == VRELOCABLE) {
	Instruction ie = getcode(fs, e);
	if (GET_OPCODE(ie) == OP_NOT) {
	fs->pc--; /* remove previous OP_NOT */
	return condjump(fs, OP_TEST, GETARG_B(ie), 0, !cond);
	}
	/* else go through */
	}
	discharge2anyreg(fs, e);
	freeexp(fs, e);
	return condjump(fs, OP_TESTSET, NO_REG, e->u.info, cond);
	}


	void luaK_goiftrue (FuncState fs, expdesc e) {
	int pc; /* pc of last jump */
	luaK_dischargevars(fs, e);
	switch (e->k) {
	case VJMP: {
	invertjump(fs, e);
	pc = e->u.info;
	break;
	}
	case VK: case VKNUM: case VTRUE: {
	pc = NO_JUMP; /* always true; do nothing */
	break;
	}
	default: {
	pc = jumponcond(fs, e, 0);
	break;
	}
	}
	luaK_concat(fs, &e->f, pc); /* insert last jump in `f' list */
	luaK_patchtohere(fs, e->t);
	e->t = NO_JUMP;
	}


	void luaK_goiffalse (FuncState fs, expdesc e) {
	int pc; /* pc of last jump */
	luaK_dischargevars(fs, e);
	switch (e->k) {
	case VJMP: {
	pc = e->u.info;
	break;
	}
	case VNIL: case VFALSE: {
	pc = NO_JUMP; /* always false; do nothing */
	break;
	}
	default: {
	pc = jumponcond(fs, e, 1);
	break;
	}
	}
	luaK_concat(fs, &e->t, pc); /* insert last jump in `t' list */
	luaK_patchtohere(fs, e->f);
	e->f = NO_JUMP;
	}


	static void codenot (FuncState fs, expdesc e) {
	luaK_dischargevars(fs, e);
	switch (e->k) {
	case VNIL: case VFALSE: {
	e->k = VTRUE;
	break;
	}
	case VK: case VKNUM: case VTRUE: {
	e->k = VFALSE;
	break;
	}
	case VJMP: {
	invertjump(fs, e);
	break;
	}
	case VRELOCABLE:
	case VNONRELOC: {
	discharge2anyreg(fs, e);
	freeexp(fs, e);
	e->u.info = luaK_codeABC(fs, OP_NOT, 0, e->u.info, 0);
	e->k = VRELOCABLE;
	break;
	}
	default: {
	lua_assert(0); /* cannot happen */
	break;
	}
	}
	/* interchange true and false lists */
	{ int temp = e->f; e->f = e->t; e->t = temp; }
	removevalues(fs, e->f);
	removevalues(fs, e->t);
	}


	void luaK_indexed (FuncState fs, expdesc t, expdesc *k) {
	lua_assert(!hasjumps(t));
	t->u.ind.t = t->u.info;
	t->u.ind.idx = luaK_exp2RK(fs, k);
	t->u.ind.vt = (t->k == VUPVAL) ? VUPVAL
	: check_exp(vkisinreg(t->k), VLOCAL);
	t->k = VINDEXED;
	}


	static int constfolding (OpCode op, expdesc e1, expdesc e2) {
	lua_Number r;
	if (!isnumeral(e1) \|\| !isnumeral(e2)) return 0;
	if ((op == OP_DIV \|\| op == OP_MOD) && e2->u.nval == 0)
	return 0; /* do not attempt to divide by 0 */
	/*
	* Patched: check for MIN_INT / -1
	*/
	if (op == OP_DIV && e1->u.nval == INT64_MIN && e2->u.nval == -1)
	return 0;
	r = luaO_arith(op - OP_ADD + LUA_OPADD, e1->u.nval, e2->u.nval);
	e1->u.nval = r;
	return 1;
	}


	static void codearith (FuncState *fs, OpCode op,
	expdesc e1, expdesc e2, int line) {
	if (constfolding(op, e1, e2))
	return;
	else {
	int o2 = (op != OP_UNM && op != OP_LEN) ? luaK_exp2RK(fs, e2) : 0;
	int o1 = luaK_exp2RK(fs, e1);
	if (o1 > o2) {
	freeexp(fs, e1);
	freeexp(fs, e2);
	}
	else {
	freeexp(fs, e2);
	freeexp(fs, e1);
	}
	e1->u.info = luaK_codeABC(fs, op, 0, o1, o2);
	e1->k = VRELOCABLE;
	luaK_fixline(fs, line);
	}
	}


	static void codecomp (FuncState fs, OpCode op, int cond, expdesc e1,
	expdesc *e2) {
	int o1 = luaK_exp2RK(fs, e1);
	int o2 = luaK_exp2RK(fs, e2);
	freeexp(fs, e2);
	freeexp(fs, e1);
	if (cond == 0 && op != OP_EQ) {
	int temp; /* exchange args to replace by `<' or `<=' */
	temp = o1; o1 = o2; o2 = temp; /* o1 <==> o2 */
	cond = 1;
	}
	e1->u.info = condjump(fs, op, cond, o1, o2);
	e1->k = VJMP;
	}


	void luaK_prefix (FuncState fs, UnOpr op, expdesc e, int line) {
	expdesc e2;
	e2.t = e2.f = NO_JUMP; e2.k = VKNUM; e2.u.nval = 0;
	switch (op) {
	case OPR_MINUS: {
	if (isnumeral(e)) /* minus constant? */
	e->u.nval = luai_numunm(NULL, e->u.nval); /* fold it */
	else {
	luaK_exp2anyreg(fs, e);
	codearith(fs, OP_UNM, e, &e2, line);
	}
	break;
	}
	case OPR_NOT: codenot(fs, e); break;
	case OPR_LEN: {
	luaK_exp2anyreg(fs, e); /* cannot operate on constants */
	codearith(fs, OP_LEN, e, &e2, line);
	break;
	}
	default: lua_assert(0);
	}
	}


	void luaK_infix (FuncState fs, BinOpr op, expdesc v) {
	switch (op) {
	case OPR_AND: {
	luaK_goiftrue(fs, v);
	break;
	}
	case OPR_OR: {
	luaK_goiffalse(fs, v);
	break;
	}
	case OPR_CONCAT: {
	luaK_exp2nextreg(fs, v); /* operand must be on the `stack' */
	break;
	}
	case OPR_ADD: case OPR_SUB: case OPR_MUL: case OPR_DIV:
	case OPR_MOD: case OPR_POW: {
	if (!isnumeral(v)) luaK_exp2RK(fs, v);
	break;
	}
	default: {
	luaK_exp2RK(fs, v);
	break;
	}
	}
	}


	void luaK_posfix (FuncState *fs, BinOpr op,
	expdesc e1, expdesc e2, int line) {
	switch (op) {
	case OPR_AND: {
	lua_assert(e1->t == NO_JUMP); /* list must be closed */
	luaK_dischargevars(fs, e2);
	luaK_concat(fs, &e2->f, e1->f);
	e1 = e2;
	break;
	}
	case OPR_OR: {
	lua_assert(e1->f == NO_JUMP); /* list must be closed */
	luaK_dischargevars(fs, e2);
	luaK_concat(fs, &e2->t, e1->t);
	e1 = e2;
	break;
	}
	case OPR_CONCAT: {
	luaK_exp2val(fs, e2);
	if (e2->k == VRELOCABLE && GET_OPCODE(getcode(fs, e2)) == OP_CONCAT) {
	lua_assert(e1->u.info == GETARG_B(getcode(fs, e2))-1);
	freeexp(fs, e1);
	SETARG_B(getcode(fs, e2), e1->u.info);
	e1->k = VRELOCABLE; e1->u.info = e2->u.info;
	}
	else {
	luaK_exp2nextreg(fs, e2); /* operand must be on the 'stack' */
	codearith(fs, OP_CONCAT, e1, e2, line);
	}
	break;
	}
	case OPR_ADD: case OPR_SUB: case OPR_MUL: case OPR_DIV:
	case OPR_MOD: case OPR_POW: {
	codearith(fs, cast(OpCode, op - OPR_ADD + OP_ADD), e1, e2, line);
	break;
	}
	case OPR_EQ: case OPR_LT: case OPR_LE: {
	codecomp(fs, cast(OpCode, op - OPR_EQ + OP_EQ), 1, e1, e2);
	break;
	}
	case OPR_NE: case OPR_GT: case OPR_GE: {
	codecomp(fs, cast(OpCode, op - OPR_NE + OP_EQ), 0, e1, e2);
	break;
	}
	default: lua_assert(0);
	}
	}


	void luaK_fixline (FuncState *fs, int line) {
	fs->f->lineinfo[fs->pc - 1] = line;
	}


	void luaK_setlist (FuncState *fs, int base, int nelems, int tostore) {
	int c = (nelems - 1)/LFIELDS_PER_FLUSH + 1;
	int b = (tostore == LUA_MULTRET) ? 0 : tostore;
	lua_assert(tostore != 0);
	if (c <= MAXARG_C)
	luaK_codeABC(fs, OP_SETLIST, base, b, c);
	else if (c <= MAXARG_Ax) {
	luaK_codeABC(fs, OP_SETLIST, base, b, 0);
	codeextraarg(fs, c);
	}
	else
	luaX_syntaxerror(fs->ls, "constructor too long");
	fs->freereg = base + 1; /* free registers with list values */
	}
	/* END CSTYLED */
	diff --git a/sys/contrib/openzfs/module/lua/lgc.c b/sys/contrib/openzfs/module/lua/lgc.c
	index 55feb24119d3..227ad723a0b8 100644
	--- a/sys/contrib/openzfs/module/lua/lgc.c
	+++ b/sys/contrib/openzfs/module/lua/lgc.c
	@@ -1,1218 +1,1218 @@
	/* BEGIN CSTYLED */
	/*
	** $Id: lgc.c,v 2.140.1.3 2014/09/01 16:55:08 roberto Exp $
	** Garbage Collector
	** See Copyright Notice in lua.h
	*/

	#define lgc_c
	#define LUA_CORE

	#include <sys/lua/lua.h>

	#include "ldebug.h"
	#include "ldo.h"
	#include "lfunc.h"
	#include "lgc.h"
	#include "lmem.h"
	#include "lobject.h"
	#include "lstate.h"
	#include "lstring.h"
	#include "ltable.h"
	#include "ltm.h"



	/*
	** cost of sweeping one element (the size of a small object divided
	** by some adjust for the sweep speed)
	*/
	#define GCSWEEPCOST ((sizeof(TString) + 4) / 4)

	/* maximum number of elements to sweep in each single step */
	#define GCSWEEPMAX (cast_int((GCSTEPSIZE / GCSWEEPCOST) / 4))

	/* maximum number of finalizers to call in each GC step */
	#define GCFINALIZENUM 4


	/*
	** macro to adjust 'stepmul': 'stepmul' is actually used like
	** 'stepmul / STEPMULADJ' (value chosen by tests)
	*/
	#define STEPMULADJ 200


	/*
	** macro to adjust 'pause': 'pause' is actually used like
	** 'pause / PAUSEADJ' (value chosen by tests)
	*/
	#define PAUSEADJ 100


	/*
	** 'makewhite' erases all color bits plus the old bit and then
	** sets only the current white bit
	*/
	#define maskcolors (~(bit2mask(BLACKBIT, OLDBIT) \| WHITEBITS))
	#define makewhite(g,x) \
	(gch(x)->marked = cast_byte((gch(x)->marked & maskcolors) \| luaC_white(g)))

	#define white2gray(x) resetbits(gch(x)->marked, WHITEBITS)
	#define black2gray(x) resetbit(gch(x)->marked, BLACKBIT)


	#define isfinalized(x) testbit(gch(x)->marked, FINALIZEDBIT)

	#define checkdeadkey(n) lua_assert(!ttisdeadkey(gkey(n)) \|\| ttisnil(gval(n)))


	#define checkconsistency(obj) \
	lua_longassert(!iscollectable(obj) \|\| righttt(obj))


	#define markvalue(g,o) { checkconsistency(o); \
	if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); }

	#define markobject(g,t) { if ((t) && iswhite(obj2gco(t))) \
	reallymarkobject(g, obj2gco(t)); }

	static void reallymarkobject (global_State g, GCObject o);


	/*
	** {======================================================
	** Generic functions
	** =======================================================
	*/


	/*
	** one after last element in a hash array
	*/
	#define gnodelast(h) gnode(h, cast(size_t, sizenode(h)))


	/*
	** link table 'h' into list pointed by 'p'
	*/
	#define linktable(h,p) ((h)->gclist = (p), (p) = obj2gco(h))


	/*
	** if key is not marked, mark its entry as dead (therefore removing it
	** from the table)
	*/
	static void removeentry (Node *n) {
	lua_assert(ttisnil(gval(n)));
	if (valiswhite(gkey(n)))
	setdeadvalue(gkey(n)); /* unused and unmarked key; remove it */
	}


	/*
	** tells whether a key or value can be cleared from a weak
	** table. Non-collectable objects are never removed from weak
	** tables. Strings behave as `values', so are never removed too. for
	** other objects: if really collected, cannot keep them; for objects
	** being finalized, keep them in keys, but not in values
	*/
	static int iscleared (global_State g, const TValue o) {
	if (!iscollectable(o)) return 0;
	else if (ttisstring(o)) {
	markobject(g, rawtsvalue(o)); /* strings are `values', so are never weak */
	return 0;
	}
	else return iswhite(gcvalue(o));
	}


	/*
	** barrier that moves collector forward, that is, mark the white object
	** being pointed by a black object.
	*/
	void luaC_barrier_ (lua_State L, GCObject o, GCObject *v) {
	global_State *g = G(L);
	lua_assert(isblack(o) && iswhite(v) && !isdead(g, v) && !isdead(g, o));
	lua_assert(g->gcstate != GCSpause);
	lua_assert(gch(o)->tt != LUA_TTABLE);
	if (keepinvariantout(g)) /* must keep invariant? */
	reallymarkobject(g, v); /* restore invariant */
	else { /* sweep phase */
	lua_assert(issweepphase(g));
	makewhite(g, o); /* mark main obj. as white to avoid other barriers */
	}
	}


	/*
	** barrier that moves collector backward, that is, mark the black object
	** pointing to a white object as gray again. (Current implementation
	** only works for tables; access to 'gclist' is not uniform across
	** different types.)
	*/
	void luaC_barrierback_ (lua_State L, GCObject o) {
	global_State *g = G(L);
	lua_assert(isblack(o) && !isdead(g, o) && gch(o)->tt == LUA_TTABLE);
	black2gray(o); /* make object gray (again) */
	gco2t(o)->gclist = g->grayagain;
	g->grayagain = o;
	}


	/*
	** barrier for prototypes. When creating first closure (cache is
	** NULL), use a forward barrier; this may be the only closure of the
	** prototype (if it is a "regular" function, with a single instance)
	** and the prototype may be big, so it is better to avoid traversing
	** it again. Otherwise, use a backward barrier, to avoid marking all
	** possible instances.
	*/
	LUAI_FUNC void luaC_barrierproto_ (lua_State L, Proto p, Closure *c) {
	global_State *g = G(L);
	lua_assert(isblack(obj2gco(p)));
	if (p->cache == NULL) { /* first time? */
	luaC_objbarrier(L, p, c);
	}
	else { /* use a backward barrier */
	black2gray(obj2gco(p)); /* make prototype gray (again) */
	p->gclist = g->grayagain;
	g->grayagain = obj2gco(p);
	}
	}


	/*
	** check color (and invariants) for an upvalue that was closed,
	** i.e., moved into the 'allgc' list
	*/
	void luaC_checkupvalcolor (global_State g, UpVal uv) {
	GCObject *o = obj2gco(uv);
	lua_assert(!isblack(o)); /* open upvalues are never black */
	if (isgray(o)) {
	if (keepinvariant(g)) {
	resetoldbit(o); /* see MOVE OLD rule */
	gray2black(o); /* it is being visited now */
	markvalue(g, uv->v);
	}
	else {
	lua_assert(issweepphase(g));
	makewhite(g, o);
	}
	}
	}


	/*
	** create a new collectable object (with given type and size) and link
	** it to '*list'. 'offset' tells how many bytes to allocate before the
	** object itself (used only by states).
	*/
	GCObject luaC_newobj (lua_State L, int tt, size_t sz, GCObject **list,
	int offset) {
	global_State *g = G(L);
	char raw = cast(char , luaM_newobject(L, novariant(tt), sz));
	GCObject *o = obj2gco(raw + offset);
	if (list == NULL)
	list = &g->allgc; /* standard list for collectable objects */
	gch(o)->marked = luaC_white(g);
	gch(o)->tt = tt;
	gch(o)->next = *list;
	*list = o;
	return o;
	}

	/* }====================================================== */



	/*
	** {======================================================
	** Mark functions
	** =======================================================
	*/


	/*
	** mark an object. Userdata, strings, and closed upvalues are visited
	** and turned black here. Other objects are marked gray and added
	** to appropriate list to be visited (and turned black) later. (Open
	** upvalues are already linked in 'headuv' list.)
	*/
	static void reallymarkobject (global_State g, GCObject o) {
	lu_mem size;
	white2gray(o);
	switch (gch(o)->tt) {
	case LUA_TSHRSTR:
	case LUA_TLNGSTR: {
	size = sizestring(gco2ts(o));
	break; /* nothing else to mark; make it black */
	}
	case LUA_TUSERDATA: {
	Table *mt = gco2u(o)->metatable;
	markobject(g, mt);
	markobject(g, gco2u(o)->env);
	size = sizeudata(gco2u(o));
	break;
	}
	case LUA_TUPVAL: {
	UpVal *uv = gco2uv(o);
	markvalue(g, uv->v);
	if (uv->v != &uv->u.value) /* open? */
	return; /* open upvalues remain gray */
	size = sizeof(UpVal);
	break;
	}
	case LUA_TLCL: {
	gco2lcl(o)->gclist = g->gray;
	g->gray = o;
	return;
	}
	case LUA_TCCL: {
	gco2ccl(o)->gclist = g->gray;
	g->gray = o;
	return;
	}
	case LUA_TTABLE: {
	linktable(gco2t(o), &g->gray);
	return;
	}
	case LUA_TTHREAD: {
	gco2th(o)->gclist = g->gray;
	g->gray = o;
	return;
	}
	case LUA_TPROTO: {
	gco2p(o)->gclist = g->gray;
	g->gray = o;
	return;
	}
	default: lua_assert(0); return;
	}
	gray2black(o);
	g->GCmemtrav += size;
	}


	/*
	** mark metamethods for basic types
	*/
	static void markmt (global_State *g) {
	int i;
	for (i=0; i < LUA_NUMTAGS; i++)
	markobject(g, g->mt[i]);
	}


	/*
	** mark all objects in list of being-finalized
	*/
	static void markbeingfnz (global_State *g) {
	GCObject *o;
	for (o = g->tobefnz; o != NULL; o = gch(o)->next) {
	makewhite(g, o);
	reallymarkobject(g, o);
	}
	}


	/*
	** mark all values stored in marked open upvalues. (See comment in
	** 'lstate.h'.)
	*/
	static void remarkupvals (global_State *g) {
	UpVal *uv;
	for (uv = g->uvhead.u.l.next; uv != &g->uvhead; uv = uv->u.l.next) {
	if (isgray(obj2gco(uv)))
	markvalue(g, uv->v);
	}
	}


	/*
	** mark root set and reset all gray lists, to start a new
	** incremental (or full) collection
	*/
	static void restartcollection (global_State *g) {
	g->gray = g->grayagain = NULL;
	g->weak = g->allweak = g->ephemeron = NULL;
	markobject(g, g->mainthread);
	markvalue(g, &g->l_registry);
	markmt(g);
	markbeingfnz(g); /* mark any finalizing object left from previous cycle */
	}

	/* }====================================================== */


	/*
	** {======================================================
	** Traverse functions
	** =======================================================
	*/

	static void traverseweakvalue (global_State g, Table h) {
	Node n, limit = gnodelast(h);
	/* if there is array part, assume it may have white values (do not
	traverse it just to check) */
	int hasclears = (h->sizearray > 0);
	for (n = gnode(h, 0); n < limit; n++) {
	checkdeadkey(n);
	if (ttisnil(gval(n))) /* entry is empty? */
	removeentry(n); /* remove it */
	else {
	lua_assert(!ttisnil(gkey(n)));
	markvalue(g, gkey(n)); /* mark key */
	if (!hasclears && iscleared(g, gval(n))) /* is there a white value? */
	hasclears = 1; /* table will have to be cleared */
	}
	}
	if (hasclears)
	linktable(h, &g->weak); /* has to be cleared later */
	else /* no white values */
	linktable(h, &g->grayagain); /* no need to clean */
	}


	static int traverseephemeron (global_State g, Table h) {
	int marked = 0; /* true if an object is marked in this traversal */
	int hasclears = 0; /* true if table has white keys */
	int prop = 0; /* true if table has entry "white-key -> white-value" */
	Node n, limit = gnodelast(h);
	int i;
	/* traverse array part (numeric keys are 'strong') */
	for (i = 0; i < h->sizearray; i++) {
	if (valiswhite(&h->array[i])) {
	marked = 1;
	reallymarkobject(g, gcvalue(&h->array[i]));
	}
	}
	/* traverse hash part */
	for (n = gnode(h, 0); n < limit; n++) {
	checkdeadkey(n);
	if (ttisnil(gval(n))) /* entry is empty? */
	removeentry(n); /* remove it */
	else if (iscleared(g, gkey(n))) { /* key is not marked (yet)? */
	hasclears = 1; /* table must be cleared */
	if (valiswhite(gval(n))) /* value not marked yet? */
	prop = 1; /* must propagate again */
	}
	else if (valiswhite(gval(n))) { /* value not marked yet? */
	marked = 1;
	reallymarkobject(g, gcvalue(gval(n))); /* mark it now */
	}
	}
	if (g->gcstate != GCSatomic \|\| prop)
	linktable(h, &g->ephemeron); /* have to propagate again */
	else if (hasclears) /* does table have white keys? */
	linktable(h, &g->allweak); /* may have to clean white keys */
	else /* no white keys */
	linktable(h, &g->grayagain); /* no need to clean */
	return marked;
	}


	static void traversestrongtable (global_State g, Table h) {
	Node n, limit = gnodelast(h);
	int i;
	for (i = 0; i < h->sizearray; i++) /* traverse array part */
	markvalue(g, &h->array[i]);
	for (n = gnode(h, 0); n < limit; n++) { /* traverse hash part */
	checkdeadkey(n);
	if (ttisnil(gval(n))) /* entry is empty? */
	removeentry(n); /* remove it */
	else {
	lua_assert(!ttisnil(gkey(n)));
	markvalue(g, gkey(n)); /* mark key */
	markvalue(g, gval(n)); /* mark value */
	}
	}
	}


	static lu_mem traversetable (global_State g, Table h) {
	const char weakkey, weakvalue;
	const TValue *mode = gfasttm(g, h->metatable, TM_MODE);
	markobject(g, h->metatable);
	if (mode && ttisstring(mode) && /* is there a weak mode? */
	((weakkey = strchr(svalue(mode), 'k')),
	(weakvalue = strchr(svalue(mode), 'v')),
	(weakkey \|\| weakvalue))) { /* is really weak? */
	black2gray(obj2gco(h)); /* keep table gray */
	if (!weakkey) /* strong keys? */
	traverseweakvalue(g, h);
	else if (!weakvalue) /* strong values? */
	traverseephemeron(g, h);
	else /* all weak */
	linktable(h, &g->allweak); /* nothing to traverse now */
	}
	else /* not weak */
	traversestrongtable(g, h);
	return sizeof(Table) + sizeof(TValue) * h->sizearray +
	sizeof(Node) * cast(size_t, sizenode(h));
	}


	static int traverseproto (global_State g, Proto f) {
	int i;
	if (f->cache && iswhite(obj2gco(f->cache)))
	f->cache = NULL; /* allow cache to be collected */
	markobject(g, f->source);
	for (i = 0; i < f->sizek; i++) /* mark literals */
	markvalue(g, &f->k[i]);
	for (i = 0; i < f->sizeupvalues; i++) /* mark upvalue names */
	markobject(g, f->upvalues[i].name);
	for (i = 0; i < f->sizep; i++) /* mark nested protos */
	markobject(g, f->p[i]);
	for (i = 0; i < f->sizelocvars; i++) /* mark local-variable names */
	markobject(g, f->locvars[i].varname);
	return sizeof(Proto) + sizeof(Instruction) * f->sizecode +
	sizeof(Proto ) f->sizep +
	sizeof(TValue) * f->sizek +
	sizeof(int) * f->sizelineinfo +
	sizeof(LocVar) * f->sizelocvars +
	sizeof(Upvaldesc) * f->sizeupvalues;
	}


	static lu_mem traverseCclosure (global_State g, CClosure cl) {
	int i;
	for (i = 0; i < cl->nupvalues; i++) /* mark its upvalues */
	markvalue(g, &cl->upvalue[i]);
	return sizeCclosure(cl->nupvalues);
	}

	static lu_mem traverseLclosure (global_State g, LClosure cl) {
	int i;
	markobject(g, cl->p); /* mark its prototype */
	for (i = 0; i < cl->nupvalues; i++) /* mark its upvalues */
	markobject(g, cl->upvals[i]);
	return sizeLclosure(cl->nupvalues);
	}


	static lu_mem traversestack (global_State g, lua_State th) {
	int n = 0;
	StkId o = th->stack;
	if (o == NULL)
	return 1; /* stack not completely built yet */
	for (; o < th->top; o++) /* mark live elements in the stack */
	markvalue(g, o);
	if (g->gcstate == GCSatomic) { /* final traversal? */
	StkId lim = th->stack + th->stacksize; /* real end of stack */
	for (; o < lim; o++) /* clear not-marked stack slice */
	setnilvalue(o);
	}
	else { /* count call infos to compute size */
	CallInfo *ci;
	for (ci = &th->base_ci; ci != th->ci; ci = ci->next)
	n++;
	}
	return sizeof(lua_State) + sizeof(TValue) * th->stacksize +
	sizeof(CallInfo) * n;
	}


	/*
	** traverse one gray object, turning it to black (except for threads,
	** which are always gray).
	*/
	static void propagatemark (global_State *g) {
	lu_mem size;
	GCObject *o = g->gray;
	lua_assert(isgray(o));
	gray2black(o);
	switch (gch(o)->tt) {
	case LUA_TTABLE: {
	Table *h = gco2t(o);
	g->gray = h->gclist; /* remove from 'gray' list */
	size = traversetable(g, h);
	break;
	}
	case LUA_TLCL: {
	LClosure *cl = gco2lcl(o);
	g->gray = cl->gclist; /* remove from 'gray' list */
	size = traverseLclosure(g, cl);
	break;
	}
	case LUA_TCCL: {
	CClosure *cl = gco2ccl(o);
	g->gray = cl->gclist; /* remove from 'gray' list */
	size = traverseCclosure(g, cl);
	break;
	}
	case LUA_TTHREAD: {
	lua_State *th = gco2th(o);
	g->gray = th->gclist; /* remove from 'gray' list */
	th->gclist = g->grayagain;
	g->grayagain = o; /* insert into 'grayagain' list */
	black2gray(o);
	size = traversestack(g, th);
	break;
	}
	case LUA_TPROTO: {
	Proto *p = gco2p(o);
	g->gray = p->gclist; /* remove from 'gray' list */
	size = traverseproto(g, p);
	break;
	}
	default: lua_assert(0); return;
	}
	g->GCmemtrav += size;
	}


	static void propagateall (global_State *g) {
	while (g->gray) propagatemark(g);
	}


	static void propagatelist (global_State g, GCObject l) {
	lua_assert(g->gray == NULL); /* no grays left */
	g->gray = l;
	propagateall(g); /* traverse all elements from 'l' */
	}

	/*
	** retraverse all gray lists. Because tables may be reinserted in other
	** lists when traversed, traverse the original lists to avoid traversing
	** twice the same table (which is not wrong, but inefficient)
	*/
	static void retraversegrays (global_State *g) {
	GCObject weak = g->weak; / save original lists */
	GCObject *grayagain = g->grayagain;
	GCObject *ephemeron = g->ephemeron;
	g->weak = g->grayagain = g->ephemeron = NULL;
	propagateall(g); /* traverse main gray list */
	propagatelist(g, grayagain);
	propagatelist(g, weak);
	propagatelist(g, ephemeron);
	}


	static void convergeephemerons (global_State *g) {
	int changed;
	do {
	GCObject *w;
	GCObject next = g->ephemeron; / get ephemeron list */
	g->ephemeron = NULL; /* tables will return to this list when traversed */
	changed = 0;
	while ((w = next) != NULL) {
	next = gco2t(w)->gclist;
	if (traverseephemeron(g, gco2t(w))) { /* traverse marked some value? */
	propagateall(g); /* propagate changes */
	changed = 1; /* will have to revisit all ephemeron tables */
	}
	}
	} while (changed);
	}

	/* }====================================================== */


	/*
	** {======================================================
	** Sweep Functions
	** =======================================================
	*/


	/*
	** clear entries with unmarked keys from all weaktables in list 'l' up
	** to element 'f'
	*/
	static void clearkeys (global_State g, GCObject l, GCObject *f) {
	for (; l != f; l = gco2t(l)->gclist) {
	Table *h = gco2t(l);
	Node n, limit = gnodelast(h);
	for (n = gnode(h, 0); n < limit; n++) {
	if (!ttisnil(gval(n)) && (iscleared(g, gkey(n)))) {
	setnilvalue(gval(n)); /* remove value ... */
	removeentry(n); /* and remove entry from table */
	}
	}
	}
	}


	/*
	** clear entries with unmarked values from all weaktables in list 'l' up
	** to element 'f'
	*/
	static void clearvalues (global_State g, GCObject l, GCObject *f) {
	for (; l != f; l = gco2t(l)->gclist) {
	Table *h = gco2t(l);
	Node n, limit = gnodelast(h);
	int i;
	for (i = 0; i < h->sizearray; i++) {
	TValue *o = &h->array[i];
	if (iscleared(g, o)) /* value was collected? */
	setnilvalue(o); /* remove value */
	}
	for (n = gnode(h, 0); n < limit; n++) {
	if (!ttisnil(gval(n)) && iscleared(g, gval(n))) {
	setnilvalue(gval(n)); /* remove value ... */
	removeentry(n); /* and remove entry from table */
	}
	}
	}
	}


	static void freeobj (lua_State L, GCObject o) {
	switch (gch(o)->tt) {
	case LUA_TPROTO: luaF_freeproto(L, gco2p(o)); break;
	case LUA_TLCL: {
	luaM_freemem(L, o, sizeLclosure(gco2lcl(o)->nupvalues));
	break;
	}
	case LUA_TCCL: {
	luaM_freemem(L, o, sizeCclosure(gco2ccl(o)->nupvalues));
	break;
	}
	case LUA_TUPVAL: luaF_freeupval(L, gco2uv(o)); break;
	case LUA_TTABLE: luaH_free(L, gco2t(o)); break;
	case LUA_TTHREAD: luaE_freethread(L, gco2th(o)); break;
	case LUA_TUSERDATA: luaM_freemem(L, o, sizeudata(gco2u(o))); break;
	case LUA_TSHRSTR:
	G(L)->strt.nuse--;
	- /* FALLTHROUGH */
	+ fallthrough;
	case LUA_TLNGSTR: {
	luaM_freemem(L, o, sizestring(gco2ts(o)));
	break;
	}
	default: lua_assert(0);
	}
	}


	#define sweepwholelist(L,p) sweeplist(L,p,MAX_LUMEM)
	static GCObject *sweeplist (lua_State L, GCObject **p, lu_mem count);


	/*
	** sweep the (open) upvalues of a thread and resize its stack and
	** list of call-info structures.
	*/
	static void sweepthread (lua_State L, lua_State L1) {
	if (L1->stack == NULL) return; /* stack not completely built yet */
	sweepwholelist(L, &L1->openupval); /* sweep open upvalues */
	luaE_freeCI(L1); /* free extra CallInfo slots */
	/* should not change the stack during an emergency gc cycle */
	if (G(L)->gckind != KGC_EMERGENCY)
	luaD_shrinkstack(L1);
	}


	/*
	** sweep at most 'count' elements from a list of GCObjects erasing dead
	** objects, where a dead (not alive) object is one marked with the "old"
	** (non current) white and not fixed.
	** In non-generational mode, change all non-dead objects back to white,
	** preparing for next collection cycle.
	** In generational mode, keep black objects black, and also mark them as
	** old; stop when hitting an old object, as all objects after that
	** one will be old too.
	** When object is a thread, sweep its list of open upvalues too.
	*/
	static GCObject *sweeplist (lua_State L, GCObject **p, lu_mem count) {
	global_State *g = G(L);
	int ow = otherwhite(g);
	int toclear, toset; /* bits to clear and to set in all live objects */
	int tostop; /* stop sweep when this is true */
	if (isgenerational(g)) { /* generational mode? */
	toclear = ~0; /* clear nothing */
	toset = bitmask(OLDBIT); /* set the old bit of all surviving objects */
	tostop = bitmask(OLDBIT); /* do not sweep old generation */
	}
	else { /* normal mode */
	toclear = maskcolors; /* clear all color bits + old bit */
	toset = luaC_white(g); /* make object white */
	tostop = 0; /* do not stop */
	}
	while (*p != NULL && count-- > 0) {
	GCObject curr = p;
	int marked = gch(curr)->marked;
	if (isdeadm(ow, marked)) { /* is 'curr' dead? */
	p = gch(curr)->next; / remove 'curr' from list */
	freeobj(L, curr); /* erase 'curr' */
	}
	else {
	if (testbits(marked, tostop))
	return NULL; /* stop sweeping this list */
	if (gch(curr)->tt == LUA_TTHREAD)
	sweepthread(L, gco2th(curr)); /* sweep thread's upvalues */
	/* update marks */
	gch(curr)->marked = cast_byte((marked & toclear) \| toset);
	p = &gch(curr)->next; /* go to next element */
	}
	}
	return (*p == NULL) ? NULL : p;
	}


	/*
	** sweep a list until a live object (or end of list)
	*/
	static GCObject *sweeptolive (lua_State L, GCObject *p, int n) {
	GCObject ** old = p;
	int i = 0;
	do {
	i++;
	p = sweeplist(L, p, 1);
	} while (p == old);
	if (n) *n += i;
	return p;
	}

	/* }====================================================== */


	/*
	** {======================================================
	** Finalization
	** =======================================================
	*/

	static void checkSizes (lua_State *L) {
	global_State *g = G(L);
	if (g->gckind != KGC_EMERGENCY) { /* do not change sizes in emergency */
	int hs = g->strt.size / 2; /* half the size of the string table */
	if (g->strt.nuse < cast(lu_int32, hs)) /* using less than that half? */
	luaS_resize(L, hs); /* halve its size */
	luaZ_freebuffer(L, &g->buff); /* free concatenation buffer */
	}
	}


	static GCObject udata2finalize (global_State g) {
	GCObject o = g->tobefnz; / get first element */
	lua_assert(isfinalized(o));
	g->tobefnz = gch(o)->next; /* remove it from 'tobefnz' list */
	gch(o)->next = g->allgc; /* return it to 'allgc' list */
	g->allgc = o;
	resetbit(gch(o)->marked, SEPARATED); /* mark that it is not in 'tobefnz' */
	lua_assert(!isold(o)); /* see MOVE OLD rule */
	if (!keepinvariantout(g)) /* not keeping invariant? */
	makewhite(g, o); /* "sweep" object */
	return o;
	}


	static void dothecall (lua_State L, void ud) {
	UNUSED(ud);
	luaD_call(L, L->top - 2, 0, 0);
	}


	static void GCTM (lua_State *L, int propagateerrors) {
	global_State *g = G(L);
	const TValue *tm;
	TValue v;
	setgcovalue(L, &v, udata2finalize(g));
	tm = luaT_gettmbyobj(L, &v, TM_GC);
	if (tm != NULL && ttisfunction(tm)) { /* is there a finalizer? */
	int status;
	lu_byte oldah = L->allowhook;
	int running = g->gcrunning;
	L->allowhook = 0; /* stop debug hooks during GC metamethod */
	g->gcrunning = 0; /* avoid GC steps */
	setobj2s(L, L->top, tm); /* push finalizer... */
	setobj2s(L, L->top + 1, &v); /* ... and its argument */
	L->top += 2; /* and (next line) call the finalizer */
	status = luaD_pcall(L, dothecall, NULL, savestack(L, L->top - 2), 0);
	L->allowhook = oldah; /* restore hooks */
	g->gcrunning = running; /* restore state */
	if (status != LUA_OK && propagateerrors) { /* error while running __gc? */
	if (status == LUA_ERRRUN) { /* is there an error object? */
	const char *msg = (ttisstring(L->top - 1))
	? svalue(L->top - 1)
	: "no message";
	luaO_pushfstring(L, "error in __gc metamethod (%s)", msg);
	status = LUA_ERRGCMM; /* error in __gc metamethod */
	}
	luaD_throw(L, status); /* re-throw error */
	}
	}
	}


	/*
	** move all unreachable objects (or 'all' objects) that need
	** finalization from list 'finobj' to list 'tobefnz' (to be finalized)
	*/
	static void separatetobefnz (lua_State *L, int all) {
	global_State *g = G(L);
	GCObject **p = &g->finobj;
	GCObject *curr;
	GCObject **lastnext = &g->tobefnz;
	/* find last 'next' field in 'tobefnz' list (to add elements in its end) */
	while (*lastnext != NULL)
	lastnext = &gch(*lastnext)->next;
	while ((curr = p) != NULL) { / traverse all finalizable objects */
	lua_assert(!isfinalized(curr));
	lua_assert(testbit(gch(curr)->marked, SEPARATED));
	if (!(iswhite(curr) \|\| all)) /* not being collected? */
	p = &gch(curr)->next; /* don't bother with it */
	else {
	l_setbit(gch(curr)->marked, FINALIZEDBIT); /* won't be finalized again */
	p = gch(curr)->next; / remove 'curr' from 'finobj' list */
	gch(curr)->next = lastnext; / link at the end of 'tobefnz' list */
	*lastnext = curr;
	lastnext = &gch(curr)->next;
	}
	}
	}


	/*
	** if object 'o' has a finalizer, remove it from 'allgc' list (must
	** search the list to find it) and link it in 'finobj' list.
	*/
	void luaC_checkfinalizer (lua_State L, GCObject o, Table *mt) {
	global_State *g = G(L);
	if (testbit(gch(o)->marked, SEPARATED) \|\| /* obj. is already separated... */
	isfinalized(o) \|\| /* ... or is finalized... */
	gfasttm(g, mt, TM_GC) == NULL) /* or has no finalizer? */
	return; /* nothing to be done */
	else { /* move 'o' to 'finobj' list */
	GCObject **p;
	GCheader *ho = gch(o);
	if (g->sweepgc == &ho->next) { /* avoid removing current sweep object */
	lua_assert(issweepphase(g));
	g->sweepgc = sweeptolive(L, g->sweepgc, NULL);
	}
	/* search for pointer pointing to 'o' */
	for (p = &g->allgc; p != o; p = &gch(p)->next) { /* empty */ }
	p = ho->next; / remove 'o' from root list */
	ho->next = g->finobj; /* link it in list 'finobj' */
	g->finobj = o;
	l_setbit(ho->marked, SEPARATED); /* mark it as such */
	if (!keepinvariantout(g)) /* not keeping invariant? */
	makewhite(g, o); /* "sweep" object */
	else
	resetoldbit(o); /* see MOVE OLD rule */
	}
	}

	/* }====================================================== */


	/*
	** {======================================================
	** GC control
	** =======================================================
	*/


	/*
	** set a reasonable "time" to wait before starting a new GC cycle;
	** cycle will start when memory use hits threshold
	*/
	static void setpause (global_State *g, l_mem estimate) {
	l_mem debt, threshold;
	estimate = estimate / PAUSEADJ; /* adjust 'estimate' */
	threshold = (g->gcpause < MAX_LMEM / estimate) /* overflow? */
	? estimate * g->gcpause /* no overflow */
	: MAX_LMEM; /* overflow; truncate to maximum */
	debt = -cast(l_mem, threshold - gettotalbytes(g));
	luaE_setdebt(g, debt);
	}


	#define sweepphases \
	(bitmask(GCSsweepstring) \| bitmask(GCSsweepudata) \| bitmask(GCSsweep))


	/*
	** enter first sweep phase (strings) and prepare pointers for other
	** sweep phases. The calls to 'sweeptolive' make pointers point to an
	** object inside the list (instead of to the header), so that the real
	** sweep do not need to skip objects created between "now" and the start
	** of the real sweep.
	** Returns how many objects it swept.
	*/
	static int entersweep (lua_State *L) {
	global_State *g = G(L);
	int n = 0;
	g->gcstate = GCSsweepstring;
	lua_assert(g->sweepgc == NULL && g->sweepfin == NULL);
	/* prepare to sweep strings, finalizable objects, and regular objects */
	g->sweepstrgc = 0;
	g->sweepfin = sweeptolive(L, &g->finobj, &n);
	g->sweepgc = sweeptolive(L, &g->allgc, &n);
	return n;
	}


	/*
	** change GC mode
	*/
	void luaC_changemode (lua_State *L, int mode) {
	global_State *g = G(L);
	if (mode == g->gckind) return; /* nothing to change */
	if (mode == KGC_GEN) { /* change to generational mode */
	/* make sure gray lists are consistent */
	luaC_runtilstate(L, bitmask(GCSpropagate));
	g->GCestimate = gettotalbytes(g);
	g->gckind = KGC_GEN;
	}
	else { /* change to incremental mode */
	/* sweep all objects to turn them back to white
	(as white has not changed, nothing extra will be collected) */
	g->gckind = KGC_NORMAL;
	entersweep(L);
	luaC_runtilstate(L, ~sweepphases);
	}
	}


	/*
	** call all pending finalizers
	*/
	static void callallpendingfinalizers (lua_State *L, int propagateerrors) {
	global_State *g = G(L);
	while (g->tobefnz) {
	resetoldbit(g->tobefnz);
	GCTM(L, propagateerrors);
	}
	}


	void luaC_freeallobjects (lua_State *L) {
	global_State *g = G(L);
	int i;
	separatetobefnz(L, 1); /* separate all objects with finalizers */
	lua_assert(g->finobj == NULL);
	callallpendingfinalizers(L, 0);
	g->currentwhite = WHITEBITS; /* this "white" makes all objects look dead */
	g->gckind = KGC_NORMAL;
	sweepwholelist(L, &g->finobj); /* finalizers can create objs. in 'finobj' */
	sweepwholelist(L, &g->allgc);
	for (i = 0; i < g->strt.size; i++) /* free all string lists */
	sweepwholelist(L, &g->strt.hash[i]);
	lua_assert(g->strt.nuse == 0);
	}


	static l_mem atomic (lua_State *L) {
	global_State *g = G(L);
	l_mem work = -cast(l_mem, g->GCmemtrav); /* start counting work */
	GCObject origweak, origall;
	lua_assert(!iswhite(obj2gco(g->mainthread)));
	markobject(g, L); /* mark running thread */
	/* registry and global metatables may be changed by API */
	markvalue(g, &g->l_registry);
	markmt(g); /* mark basic metatables */
	/* remark occasional upvalues of (maybe) dead threads */
	remarkupvals(g);
	propagateall(g); /* propagate changes */
	work += g->GCmemtrav; /* stop counting (do not (re)count grays) */
	/* traverse objects caught by write barrier and by 'remarkupvals' */
	retraversegrays(g);
	work -= g->GCmemtrav; /* restart counting */
	convergeephemerons(g);
	/* at this point, all strongly accessible objects are marked. */
	/* clear values from weak tables, before checking finalizers */
	clearvalues(g, g->weak, NULL);
	clearvalues(g, g->allweak, NULL);
	origweak = g->weak; origall = g->allweak;
	work += g->GCmemtrav; /* stop counting (objects being finalized) */
	separatetobefnz(L, 0); /* separate objects to be finalized */
	markbeingfnz(g); /* mark objects that will be finalized */
	propagateall(g); /* remark, to propagate `preserveness' */
	work -= g->GCmemtrav; /* restart counting */
	convergeephemerons(g);
	/* at this point, all resurrected objects are marked. */
	/* remove dead objects from weak tables */
	clearkeys(g, g->ephemeron, NULL); /* clear keys from all ephemeron tables */
	clearkeys(g, g->allweak, NULL); /* clear keys from all allweak tables */
	/* clear values from resurrected weak tables */
	clearvalues(g, g->weak, origweak);
	clearvalues(g, g->allweak, origall);
	g->currentwhite = cast_byte(otherwhite(g)); /* flip current white */
	work += g->GCmemtrav; /* complete counting */
	return work; /* estimate of memory marked by 'atomic' */
	}


	static lu_mem singlestep (lua_State *L) {
	global_State *g = G(L);
	switch (g->gcstate) {
	case GCSpause: {
	/* start to count memory traversed */
	g->GCmemtrav = g->strt.size * sizeof(GCObject*);
	lua_assert(!isgenerational(g));
	restartcollection(g);
	g->gcstate = GCSpropagate;
	return g->GCmemtrav;
	}
	case GCSpropagate: {
	if (g->gray) {
	lu_mem oldtrav = g->GCmemtrav;
	propagatemark(g);
	return g->GCmemtrav - oldtrav; /* memory traversed in this step */
	}
	else { /* no more `gray' objects */
	lu_mem work;
	int sw;
	g->gcstate = GCSatomic; /* finish mark phase */
	g->GCestimate = g->GCmemtrav; /* save what was counted */;
	work = atomic(L); /* add what was traversed by 'atomic' */
	g->GCestimate += work; /* estimate of total memory traversed */
	sw = entersweep(L);
	return work + sw * GCSWEEPCOST;
	}
	}
	case GCSsweepstring: {
	int i;
	for (i = 0; i < GCSWEEPMAX && g->sweepstrgc + i < g->strt.size; i++)
	sweepwholelist(L, &g->strt.hash[g->sweepstrgc + i]);
	g->sweepstrgc += i;
	if (g->sweepstrgc >= g->strt.size) /* no more strings to sweep? */
	g->gcstate = GCSsweepudata;
	return i * GCSWEEPCOST;
	}
	case GCSsweepudata: {
	if (g->sweepfin) {
	g->sweepfin = sweeplist(L, g->sweepfin, GCSWEEPMAX);
	return GCSWEEPMAX*GCSWEEPCOST;
	}
	else {
	g->gcstate = GCSsweep;
	return 0;
	}
	}
	case GCSsweep: {
	if (g->sweepgc) {
	g->sweepgc = sweeplist(L, g->sweepgc, GCSWEEPMAX);
	return GCSWEEPMAX*GCSWEEPCOST;
	}
	else {
	/* sweep main thread */
	GCObject *mt = obj2gco(g->mainthread);
	sweeplist(L, &mt, 1);
	checkSizes(L);
	g->gcstate = GCSpause; /* finish collection */
	return GCSWEEPCOST;
	}
	}
	default: lua_assert(0); return 0;
	}
	}


	/*
	** advances the garbage collector until it reaches a state allowed
	** by 'statemask'
	*/
	void luaC_runtilstate (lua_State *L, int statesmask) {
	global_State *g = G(L);
	while (!testbit(statesmask, g->gcstate))
	singlestep(L);
	}


	static void generationalcollection (lua_State *L) {
	global_State *g = G(L);
	lua_assert(g->gcstate == GCSpropagate);
	if (g->GCestimate == 0) { /* signal for another major collection? */
	luaC_fullgc(L, 0); /* perform a full regular collection */
	g->GCestimate = gettotalbytes(g); /* update control */
	}
	else {
	lu_mem estimate = g->GCestimate;
	luaC_runtilstate(L, bitmask(GCSpause)); /* run complete (minor) cycle */
	g->gcstate = GCSpropagate; /* skip restart */
	if (gettotalbytes(g) > (estimate / 100) * g->gcmajorinc)
	g->GCestimate = 0; /* signal for a major collection */
	else
	g->GCestimate = estimate; /* keep estimate from last major coll. */

	}
	setpause(g, gettotalbytes(g));
	lua_assert(g->gcstate == GCSpropagate);
	}


	static void incstep (lua_State *L) {
	global_State *g = G(L);
	l_mem debt = g->GCdebt;
	int stepmul = g->gcstepmul;
	if (stepmul < 40) stepmul = 40; /* avoid ridiculous low values (and 0) */
	/* convert debt from Kb to 'work units' (avoid zero debt and overflows) */
	debt = (debt / STEPMULADJ) + 1;
	debt = (debt < MAX_LMEM / stepmul) ? debt * stepmul : MAX_LMEM;
	do { /* always perform at least one single step */
	lu_mem work = singlestep(L); /* do some work */
	debt -= work;
	} while (debt > -GCSTEPSIZE && g->gcstate != GCSpause);
	if (g->gcstate == GCSpause)
	setpause(g, g->GCestimate); /* pause until next cycle */
	else {
	debt = (debt / stepmul) * STEPMULADJ; /* convert 'work units' to Kb */
	luaE_setdebt(g, debt);
	}
	}


	/*
	** performs a basic GC step
	*/
	void luaC_forcestep (lua_State *L) {
	global_State *g = G(L);
	int i;
	if (isgenerational(g)) generationalcollection(L);
	else incstep(L);
	/* run a few finalizers (or all of them at the end of a collect cycle) */
	for (i = 0; g->tobefnz && (i < GCFINALIZENUM \|\| g->gcstate == GCSpause); i++)
	GCTM(L, 1); /* call one finalizer */
	}


	/*
	** performs a basic GC step only if collector is running
	*/
	void luaC_step (lua_State *L) {
	global_State *g = G(L);
	if (g->gcrunning) luaC_forcestep(L);
	else luaE_setdebt(g, -GCSTEPSIZE); /* avoid being called too often */
	}



	/*
	** performs a full GC cycle; if "isemergency", does not call
	** finalizers (which could change stack positions)
	*/
	void luaC_fullgc (lua_State *L, int isemergency) {
	global_State *g = G(L);
	int origkind = g->gckind;
	lua_assert(origkind != KGC_EMERGENCY);
	if (isemergency) /* do not run finalizers during emergency GC */
	g->gckind = KGC_EMERGENCY;
	else {
	g->gckind = KGC_NORMAL;
	callallpendingfinalizers(L, 1);
	}
	if (keepinvariant(g)) { /* may there be some black objects? */
	/* must sweep all objects to turn them back to white
	(as white has not changed, nothing will be collected) */
	entersweep(L);
	}
	/* finish any pending sweep phase to start a new cycle */
	luaC_runtilstate(L, bitmask(GCSpause));
	luaC_runtilstate(L, ~bitmask(GCSpause)); /* start new collection */
	luaC_runtilstate(L, bitmask(GCSpause)); /* run entire collection */
	if (origkind == KGC_GEN) { /* generational mode? */
	/* generational mode must be kept in propagate phase */
	luaC_runtilstate(L, bitmask(GCSpropagate));
	}
	g->gckind = origkind;
	setpause(g, gettotalbytes(g));
	if (!isemergency) /* do not run finalizers during emergency GC */
	callallpendingfinalizers(L, 1);
	}

	/* }====================================================== */
	/* END CSTYLED */
	diff --git a/sys/contrib/openzfs/module/lua/llex.c b/sys/contrib/openzfs/module/lua/llex.c
	index 50c301f599f1..f2c9bf826c82 100644
	--- a/sys/contrib/openzfs/module/lua/llex.c
	+++ b/sys/contrib/openzfs/module/lua/llex.c
	@@ -1,531 +1,531 @@
	/* BEGIN CSTYLED */
	/*
	** $Id: llex.c,v 2.63.1.3 2015/02/09 17:56:34 roberto Exp $
	** Lexical Analyzer
	** See Copyright Notice in lua.h
	*/

	#define llex_c
	#define LUA_CORE

	#include <sys/lua/lua.h>

	#include "lctype.h"
	#include "ldo.h"
	#include "llex.h"
	#include "lobject.h"
	#include "lparser.h"
	#include "lstate.h"
	#include "lstring.h"
	#include "ltable.h"
	#include "lzio.h"



	#define next(ls) (ls->current = zgetc(ls->z))



	#define currIsNewline(ls) (ls->current == '\n' \|\| ls->current == '\r')


	/* ORDER RESERVED */
	static const char *const luaX_tokens [] = {
	"and", "break", "do", "else", "elseif",
	"end", "false", "for", "function", "goto", "if",
	"in", "local", "nil", "not", "or", "repeat",
	"return", "then", "true", "until", "while",
	"..", "...", "==", ">=", "<=", "~=", "::", "<eof>",
	"<number>", "<name>", "<string>"
	};


	#define save_and_next(ls) (save(ls, ls->current), next(ls))


	static l_noret lexerror (LexState ls, const char msg, int token);


	static void save (LexState *ls, int c) {
	Mbuffer *b = ls->buff;
	if (luaZ_bufflen(b) + 1 > luaZ_sizebuffer(b)) {
	size_t newsize;
	if (luaZ_sizebuffer(b) >= MAX_SIZET/2)
	lexerror(ls, "lexical element too long", 0);
	newsize = luaZ_sizebuffer(b) * 2;
	luaZ_resizebuffer(ls->L, b, newsize);
	}
	b->buffer[luaZ_bufflen(b)++] = cast(char, c);
	}


	void luaX_init (lua_State *L) {
	int i;
	for (i=0; i<NUM_RESERVED; i++) {
	TString *ts = luaS_new(L, luaX_tokens[i]);
	luaS_fix(ts); /* reserved words are never collected */
	ts->tsv.extra = cast_byte(i+1); /* reserved word */
	}
	}


	const char luaX_token2str (LexState ls, int token) {
	if (token < FIRST_RESERVED) { /* single-byte symbols? */
	lua_assert(token == cast(unsigned char, token));
	return (lisprint(token)) ? luaO_pushfstring(ls->L, LUA_QL("%c"), token) :
	luaO_pushfstring(ls->L, "char(%d)", token);
	}
	else {
	const char *s = luaX_tokens[token - FIRST_RESERVED];
	if (token < TK_EOS) /* fixed format (symbols and reserved words)? */
	return luaO_pushfstring(ls->L, LUA_QS, s);
	else /* names, strings, and numerals */
	return s;
	}
	}


	static const char txtToken (LexState ls, int token) {
	switch (token) {
	case TK_NAME:
	case TK_STRING:
	case TK_NUMBER:
	save(ls, '\0');
	return luaO_pushfstring(ls->L, LUA_QS, luaZ_buffer(ls->buff));
	default:
	return luaX_token2str(ls, token);
	}
	}


	static l_noret lexerror (LexState ls, const char msg, int token) {
	char buff[LUA_IDSIZE];
	luaO_chunkid(buff, getstr(ls->source), LUA_IDSIZE);
	msg = luaO_pushfstring(ls->L, "%s:%d: %s", buff, ls->linenumber, msg);
	if (token)
	luaO_pushfstring(ls->L, "%s near %s", msg, txtToken(ls, token));
	luaD_throw(ls->L, LUA_ERRSYNTAX);
	}


	l_noret luaX_syntaxerror (LexState ls, const char msg) {
	lexerror(ls, msg, ls->t.token);
	}


	/*
	** creates a new string and anchors it in function's table so that
	** it will not be collected until the end of the function's compilation
	** (by that time it should be anchored in function's prototype)
	*/
	TString luaX_newstring (LexState ls, const char *str, size_t l) {
	lua_State *L = ls->L;
	TValue o; / entry for `str' */
	TString ts = luaS_newlstr(L, str, l); / create new string */
	setsvalue2s(L, L->top++, ts); /* temporarily anchor it in stack */
	o = luaH_set(L, ls->fs->h, L->top - 1);
	if (ttisnil(o)) { /* not in use yet? (see 'addK') */
	/* boolean value does not need GC barrier;
	table has no metatable, so it does not need to invalidate cache */
	setbvalue(o, 1); /* t[string] = true */
	luaC_checkGC(L);
	}
	else { /* string already present */
	ts = rawtsvalue(keyfromval(o)); /* re-use value previously stored */
	}
	L->top--; /* remove string from stack */
	return ts;
	}


	/*
	** increment line number and skips newline sequence (any of
	** \n, \r, \n\r, or \r\n)
	*/
	static void inclinenumber (LexState *ls) {
	int old = ls->current;
	lua_assert(currIsNewline(ls));
	next(ls); /* skip `\n' or `\r' */
	if (currIsNewline(ls) && ls->current != old)
	next(ls); /* skip `\n\r' or `\r\n' */
	if (++ls->linenumber >= MAX_INT)
	lexerror(ls, "chunk has too many lines", 0);
	}


	void luaX_setinput (lua_State L, LexState ls, ZIO z, TString source,
	int firstchar) {
	ls->decpoint = '.';
	ls->L = L;
	ls->current = firstchar;
	ls->lookahead.token = TK_EOS; /* no look-ahead token */
	ls->z = z;
	ls->fs = NULL;
	ls->linenumber = 1;
	ls->lastline = 1;
	ls->source = source;
	ls->envn = luaS_new(L, LUA_ENV); /* create env name */
	luaS_fix(ls->envn); /* never collect this name */
	luaZ_resizebuffer(ls->L, ls->buff, LUA_MINBUFFER); /* initialize buffer */
	}



	/*
	** =======================================================
	** LEXICAL ANALYZER
	** =======================================================
	*/



	static int check_next (LexState ls, const char set) {
	if (ls->current == '\0' \|\| !strchr(set, ls->current))
	return 0;
	save_and_next(ls);
	return 1;
	}


	/*
	** change all characters 'from' in buffer to 'to'
	*/
	static void buffreplace (LexState *ls, char from, char to) {
	size_t n = luaZ_bufflen(ls->buff);
	char *p = luaZ_buffer(ls->buff);
	while (n--)
	if (p[n] == from) p[n] = to;
	}


	#if !defined(getlocaledecpoint)
	#define getlocaledecpoint() (localeconv()->decimal_point[0])
	#endif


	#define buff2d(b,e) luaO_str2d(luaZ_buffer(b), luaZ_bufflen(b) - 1, e)

	/*
	** in case of format error, try to change decimal point separator to
	** the one defined in the current locale and check again
	*/
	static void trydecpoint (LexState ls, SemInfo seminfo) {
	char old = ls->decpoint;
	ls->decpoint = getlocaledecpoint();
	buffreplace(ls, old, ls->decpoint); /* try new decimal separator */
	if (!buff2d(ls->buff, &seminfo->r)) {
	/* format error with correct decimal point: no more options */
	buffreplace(ls, ls->decpoint, '.'); /* undo change (for error message) */
	lexerror(ls, "malformed number", TK_NUMBER);
	}
	}


	/* LUA_NUMBER */
	/*
	** this function is quite liberal in what it accepts, as 'luaO_str2d'
	** will reject ill-formed numerals.
	*/
	static void read_numeral (LexState ls, SemInfo seminfo) {
	const char *expo = "Ee";
	int first = ls->current;
	lua_assert(lisdigit(ls->current));
	save_and_next(ls);
	if (first == '0' && check_next(ls, "Xx")) /* hexadecimal? */
	expo = "Pp";
	for (;;) {
	if (check_next(ls, expo)) /* exponent part? */
	(void) check_next(ls, "+-"); /* optional exponent sign */
	if (lisxdigit(ls->current) \|\| ls->current == '.')
	save_and_next(ls);
	else break;
	}
	save(ls, '\0');
	buffreplace(ls, '.', ls->decpoint); /* follow locale for decimal point */
	if (!buff2d(ls->buff, &seminfo->r)) /* format error? */
	trydecpoint(ls, seminfo); /* try to update decimal point separator */
	}


	/*
	** skip a sequence '[=[' or ']=]' and return its number of '='s or
	** -1 if sequence is malformed
	*/
	static int skip_sep (LexState *ls) {
	int count = 0;
	int s = ls->current;
	lua_assert(s == '[' \|\| s == ']');
	save_and_next(ls);
	while (ls->current == '=') {
	save_and_next(ls);
	count++;
	}
	return (ls->current == s) ? count : (-count) - 1;
	}


	static void read_long_string (LexState ls, SemInfo seminfo, int sep) {
	save_and_next(ls); /* skip 2nd `[' */
	if (currIsNewline(ls)) /* string starts with a newline? */
	inclinenumber(ls); /* skip it */
	for (;;) {
	switch (ls->current) {
	case EOZ:
	lexerror(ls, (seminfo) ? "unfinished long string" :
	"unfinished long comment", TK_EOS);
	break; /* to avoid warnings */
	case ']': {
	if (skip_sep(ls) == sep) {
	save_and_next(ls); /* skip 2nd `]' */
	goto endloop;
	}
	break;
	}
	case '\n': case '\r': {
	save(ls, '\n');
	inclinenumber(ls);
	if (!seminfo) luaZ_resetbuffer(ls->buff); /* avoid wasting space */
	break;
	}
	default: {
	if (seminfo) save_and_next(ls);
	else next(ls);
	}
	}
	} endloop:
	if (seminfo)
	seminfo->ts = luaX_newstring(ls, luaZ_buffer(ls->buff) + (2 + sep),
	luaZ_bufflen(ls->buff) - 2*(2 + sep));
	}


	static void escerror (LexState ls, int c, int n, const char *msg) {
	int i;
	luaZ_resetbuffer(ls->buff); /* prepare error message */
	save(ls, '\\');
	for (i = 0; i < n && c[i] != EOZ; i++)
	save(ls, c[i]);
	lexerror(ls, msg, TK_STRING);
	}


	static int readhexaesc (LexState *ls) {
	int c[3], i; /* keep input for error message */
	int r = 0; /* result accumulator */
	c[0] = 'x'; /* for error message */
	for (i = 1; i < 3; i++) { /* read two hexadecimal digits */
	c[i] = next(ls);
	if (!lisxdigit(c[i]))
	escerror(ls, c, i + 1, "hexadecimal digit expected");
	r = (r << 4) + luaO_hexavalue(c[i]);
	}
	return r;
	}


	static int readdecesc (LexState *ls) {
	int c[3], i;
	int r = 0; /* result accumulator */
	for (i = 0; i < 3 && lisdigit(ls->current); i++) { /* read up to 3 digits */
	c[i] = ls->current;
	r = 10*r + c[i] - '0';
	next(ls);
	}
	if (r > UCHAR_MAX)
	escerror(ls, c, i, "decimal escape too large");
	return r;
	}


	static void read_string (LexState ls, int del, SemInfo seminfo) {
	save_and_next(ls); /* keep delimiter (for error messages) */
	while (ls->current != del) {
	switch (ls->current) {
	case EOZ:
	lexerror(ls, "unfinished string", TK_EOS);
	break; /* to avoid warnings */
	case '\n':
	case '\r':
	lexerror(ls, "unfinished string", TK_STRING);
	break; /* to avoid warnings */
	case '\\': { /* escape sequences */
	int c; /* final character to be saved */
	next(ls); /* do not save the `\' */
	switch (ls->current) {
	case 'a': c = '\a'; goto read_save;
	case 'b': c = '\b'; goto read_save;
	case 'f': c = '\f'; goto read_save;
	case 'n': c = '\n'; goto read_save;
	case 'r': c = '\r'; goto read_save;
	case 't': c = '\t'; goto read_save;
	case 'v': c = '\v'; goto read_save;
	case 'x': c = readhexaesc(ls); goto read_save;
	case '\n': case '\r':
	inclinenumber(ls); c = '\n'; goto only_save;
	case '\\': case '\"': case '\'':
	c = ls->current; goto read_save;
	case EOZ: goto no_save; /* will raise an error next loop */
	case 'z': { /* zap following span of spaces */
	next(ls); /* skip the 'z' */
	while (lisspace(ls->current)) {
	if (currIsNewline(ls)) inclinenumber(ls);
	else next(ls);
	}
	goto no_save;
	}
	default: {
	if (!lisdigit(ls->current))
	escerror(ls, &ls->current, 1, "invalid escape sequence");
	/* digital escape \ddd */
	c = readdecesc(ls);
	goto only_save;
	}
	}
	read_save: next(ls); /* read next character */
	only_save: save(ls, c); /* save 'c' */
	no_save: break;
	}
	default:
	save_and_next(ls);
	}
	}
	save_and_next(ls); /* skip delimiter */
	seminfo->ts = luaX_newstring(ls, luaZ_buffer(ls->buff) + 1,
	luaZ_bufflen(ls->buff) - 2);
	}


	static int llex (LexState ls, SemInfo seminfo) {
	luaZ_resetbuffer(ls->buff);
	for (;;) {
	switch (ls->current) {
	case '\n': case '\r': { /* line breaks */
	inclinenumber(ls);
	break;
	}
	case ' ': case '\f': case '\t': case '\v': { /* spaces */
	next(ls);
	break;
	}
	case '-': { /* '-' or '--' (comment) */
	next(ls);
	if (ls->current != '-') return '-';
	/* else is a comment */
	next(ls);
	if (ls->current == '[') { /* long comment? */
	int sep = skip_sep(ls);
	luaZ_resetbuffer(ls->buff); /* `skip_sep' may dirty the buffer */
	if (sep >= 0) {
	read_long_string(ls, NULL, sep); /* skip long comment */
	luaZ_resetbuffer(ls->buff); /* previous call may dirty the buff. */
	break;
	}
	}
	/* else short comment */
	while (!currIsNewline(ls) && ls->current != EOZ)
	next(ls); /* skip until end of line (or end of file) */
	break;
	}
	case '[': { /* long string or simply '[' */
	int sep = skip_sep(ls);
	if (sep >= 0) {
	read_long_string(ls, seminfo, sep);
	return TK_STRING;
	} else if (sep == -1) {
	return '[';
	} else {
	lexerror(ls, "invalid long string delimiter", TK_STRING);
	break;
	}
	}
	case '=': {
	next(ls);
	if (ls->current != '=') return '=';
	else { next(ls); return TK_EQ; }
	}
	case '<': {
	next(ls);
	if (ls->current != '=') return '<';
	else { next(ls); return TK_LE; }
	}
	case '>': {
	next(ls);
	if (ls->current != '=') return '>';
	else { next(ls); return TK_GE; }
	}
	case '~': {
	next(ls);
	if (ls->current != '=') return '~';
	else { next(ls); return TK_NE; }
	}
	case ':': {
	next(ls);
	if (ls->current != ':') return ':';
	else { next(ls); return TK_DBCOLON; }
	}
	case '"': case '\'': { /* short literal strings */
	read_string(ls, ls->current, seminfo);
	return TK_STRING;
	}
	case '.': { /* '.', '..', '...', or number */
	save_and_next(ls);
	if (check_next(ls, ".")) {
	if (check_next(ls, "."))
	return TK_DOTS; /* '...' */
	else return TK_CONCAT; /* '..' */
	}
	else if (!lisdigit(ls->current)) return '.';
	/* else go through */
	}
	- /* FALLTHROUGH */
	+ fallthrough;
	case '0': case '1': case '2': case '3': case '4':
	case '5': case '6': case '7': case '8': case '9': {
	read_numeral(ls, seminfo);
	return TK_NUMBER;
	}
	case EOZ: {
	return TK_EOS;
	}
	default: {
	if (lislalpha(ls->current)) { /* identifier or reserved word? */
	TString *ts;
	do {
	save_and_next(ls);
	} while (lislalnum(ls->current));
	ts = luaX_newstring(ls, luaZ_buffer(ls->buff),
	luaZ_bufflen(ls->buff));
	seminfo->ts = ts;
	if (isreserved(ts)) /* reserved word? */
	return ts->tsv.extra - 1 + FIRST_RESERVED;
	else {
	return TK_NAME;
	}
	}
	else { /* single-char tokens (+ - / ...) */
	int c = ls->current;
	next(ls);
	return c;
	}
	}
	}
	}
	}


	void luaX_next (LexState *ls) {
	ls->lastline = ls->linenumber;
	if (ls->lookahead.token != TK_EOS) { /* is there a look-ahead token? */
	ls->t = ls->lookahead; /* use this one */
	ls->lookahead.token = TK_EOS; /* and discharge it */
	}
	else
	ls->t.token = llex(ls, &ls->t.seminfo); /* read next token */
	}


	int luaX_lookahead (LexState *ls) {
	lua_assert(ls->lookahead.token == TK_EOS);
	ls->lookahead.token = llex(ls, &ls->lookahead.seminfo);
	return ls->lookahead.token;
	}
	/* END CSTYLED */
	diff --git a/sys/contrib/openzfs/module/lua/lstrlib.c b/sys/contrib/openzfs/module/lua/lstrlib.c
	index 12027757bf53..46e3d8fb35bb 100644
	--- a/sys/contrib/openzfs/module/lua/lstrlib.c
	+++ b/sys/contrib/openzfs/module/lua/lstrlib.c
	@@ -1,1040 +1,1040 @@
	/* BEGIN CSTYLED */
	/*
	** $Id: lstrlib.c,v 1.178.1.1 2013/04/12 18:48:47 roberto Exp $
	** Standard library for string operations and pattern-matching
	** See Copyright Notice in lua.h
	*/


	#define lstrlib_c
	#define LUA_LIB

	#include <sys/lua/lua.h>

	#include <sys/lua/lauxlib.h>
	#include <sys/lua/lualib.h>


	/*
	** maximum number of captures that a pattern can do during
	** pattern-matching. This limit is arbitrary.
	*/
	#if !defined(LUA_MAXCAPTURES)
	#define LUA_MAXCAPTURES 16
	#endif


	/* macro to `unsign' a character */
	#define uchar(c) ((unsigned char)(c))

	/*
	* The provided version of sprintf returns a char *, but str_format expects
	* it to return the number of characters printed. This version has the expected
	* behavior.
	*/
	static size_t str_sprintf(char buf, const char fmt, ...) {
	va_list args;
	size_t len;

	va_start(args, fmt);
	len = vsnprintf(buf, INT_MAX, fmt, args);
	va_end(args);

	return len;
	}


	static int str_len (lua_State *L) {
	size_t l;
	luaL_checklstring(L, 1, &l);
	lua_pushinteger(L, (lua_Integer)l);
	return 1;
	}


	/* translate a relative string position: negative means back from end */
	static size_t posrelat (ptrdiff_t pos, size_t len) {
	if (pos >= 0) return (size_t)pos;
	else if (0u - (size_t)pos > len) return 0;
	else return len - ((size_t)-pos) + 1;
	}


	static int str_sub (lua_State *L) {
	size_t l;
	const char *s = luaL_checklstring(L, 1, &l);
	size_t start = posrelat(luaL_checkinteger(L, 2), l);
	size_t end = posrelat(luaL_optinteger(L, 3, -1), l);
	if (start < 1) start = 1;
	if (end > l) end = l;
	if (start <= end)
	lua_pushlstring(L, s + start - 1, end - start + 1);
	else lua_pushliteral(L, "");
	return 1;
	}


	static int str_reverse (lua_State *L) {
	size_t l, i;
	luaL_Buffer b;
	const char *s = luaL_checklstring(L, 1, &l);
	char *p = luaL_buffinitsize(L, &b, l);
	for (i = 0; i < l; i++)
	p[i] = s[l - i - 1];
	luaL_pushresultsize(&b, l);
	return 1;
	}


	static int str_lower (lua_State *L) {
	size_t l;
	size_t i;
	luaL_Buffer b;
	const char *s = luaL_checklstring(L, 1, &l);
	char *p = luaL_buffinitsize(L, &b, l);
	for (i=0; i<l; i++)
	p[i] = tolower(uchar(s[i]));
	luaL_pushresultsize(&b, l);
	return 1;
	}


	static int str_upper (lua_State *L) {
	size_t l;
	size_t i;
	luaL_Buffer b;
	const char *s = luaL_checklstring(L, 1, &l);
	char *p = luaL_buffinitsize(L, &b, l);
	for (i=0; i<l; i++)
	p[i] = toupper(uchar(s[i]));
	luaL_pushresultsize(&b, l);
	return 1;
	}


	/* reasonable limit to avoid arithmetic overflow */
	#define MAXSIZE ((~(size_t)0) >> 1)

	static int str_rep (lua_State *L) {
	size_t l, lsep;
	const char *s = luaL_checklstring(L, 1, &l);
	int n = luaL_checkint(L, 2);
	const char *sep = luaL_optlstring(L, 3, "", &lsep);
	if (n <= 0) lua_pushliteral(L, "");
	else if (l + lsep < l \|\| l + lsep >= MAXSIZE / n) /* may overflow? */
	return luaL_error(L, "resulting string too large");
	else {
	size_t totallen = n * l + (n - 1) * lsep;
	luaL_Buffer b;
	char *p = luaL_buffinitsize(L, &b, totallen);
	while (n-- > 1) { /* first n-1 copies (followed by separator) */
	memcpy(p, s, l * sizeof(char)); p += l;
	if (lsep > 0) { /* avoid empty 'memcpy' (may be expensive) */
	memcpy(p, sep, lsep * sizeof(char)); p += lsep;
	}
	}
	memcpy(p, s, l * sizeof(char)); /* last copy (not followed by separator) */
	luaL_pushresultsize(&b, totallen);
	}
	return 1;
	}


	static int str_byte (lua_State *L) {
	size_t l;
	const char *s = luaL_checklstring(L, 1, &l);
	size_t posi = posrelat(luaL_optinteger(L, 2, 1), l);
	size_t pose = posrelat(luaL_optinteger(L, 3, posi), l);
	int n, i;
	if (posi < 1) posi = 1;
	if (pose > l) pose = l;
	if (posi > pose) return 0; /* empty interval; return no values */
	n = (int)(pose - posi + 1);
	if (posi + n <= pose) /* (size_t -> int) overflow? */
	return luaL_error(L, "string slice too long");
	luaL_checkstack(L, n, "string slice too long");
	for (i=0; i<n; i++)
	lua_pushinteger(L, uchar(s[posi+i-1]));
	return n;
	}


	static int str_char (lua_State *L) {
	int n = lua_gettop(L); /* number of arguments */
	int i;
	luaL_Buffer b;
	char *p = luaL_buffinitsize(L, &b, n);
	for (i=1; i<=n; i++) {
	int c = luaL_checkint(L, i);
	luaL_argcheck(L, uchar(c) == c, i, "value out of range");
	p[i - 1] = uchar(c);
	}
	luaL_pushresultsize(&b, n);
	return 1;
	}


	#if defined(LUA_USE_DUMP)
	static int writer (lua_State L, const void b, size_t size, void* B) {
	(void)L;
	luaL_addlstring((luaL_Buffer) B, (const char )b, size);
	return 0;
	}


	static int str_dump (lua_State *L) {
	luaL_Buffer b;
	luaL_checktype(L, 1, LUA_TFUNCTION);
	lua_settop(L, 1);
	luaL_buffinit(L,&b);
	if (lua_dump(L, writer, &b) != 0)
	return luaL_error(L, "unable to dump given function");
	luaL_pushresult(&b);
	return 1;
	}
	#endif


	/*
	** {======================================================
	** PATTERN MATCHING
	** =======================================================
	*/


	#define CAP_UNFINISHED (-1)
	#define CAP_POSITION (-2)


	typedef struct MatchState {
	int matchdepth; /* control for recursive depth (to avoid C stack overflow) */
	const char src_init; / init of source string */
	const char src_end; / end ('\0') of source string */
	const char p_end; / end ('\0') of pattern */
	lua_State *L;
	int level; /* total number of captures (finished or unfinished) */
	struct {
	const char *init;
	ptrdiff_t len;
	} capture[LUA_MAXCAPTURES];
	} MatchState;


	/* recursive function */
	static const char match (MatchState ms, const char s, const char p);


	/* maximum recursion depth for 'match' */
	#if !defined(MAXCCALLS)
	#define MAXCCALLS 200
	#endif


	#define L_ESC '%'
	#define SPECIALS "^$*+?.([%-"


	static int check_capture (MatchState *ms, int l) {
	l -= '1';
	if (l < 0 \|\| l >= ms->level \|\| ms->capture[l].len == CAP_UNFINISHED)
	return luaL_error(ms->L, "invalid capture index %%%d", l + 1);
	return l;
	}


	static int capture_to_close (MatchState *ms) {
	int level = ms->level;
	for (level--; level>=0; level--)
	if (ms->capture[level].len == CAP_UNFINISHED) return level;
	return luaL_error(ms->L, "invalid pattern capture");
	}


	static const char classend (MatchState ms, const char *p) {
	switch (*p++) {
	case L_ESC: {
	if (p == ms->p_end)
	luaL_error(ms->L, "malformed pattern (ends with " LUA_QL("%%") ")");
	return p+1;
	}
	case '[': {
	if (*p == '^') p++;
	do { /* look for a `]' */
	if (p == ms->p_end)
	luaL_error(ms->L, "malformed pattern (missing " LUA_QL("]") ")");
	if (*(p++) == L_ESC && p < ms->p_end)
	p++; /* skip escapes (e.g. `%]') */
	} while (*p != ']');
	return p+1;
	}
	default: {
	return p;
	}
	}
	}


	static int match_class (int c, int cl) {
	int res;
	switch (tolower(cl)) {
	case 'a' : res = isalpha(c); break;
	case 'c' : res = iscntrl(c); break;
	case 'd' : res = isdigit(c); break;
	case 'g' : res = isgraph(c); break;
	case 'l' : res = islower(c); break;
	case 'p' : res = ispunct(c); break;
	case 's' : res = isspace(c); break;
	case 'u' : res = isupper(c); break;
	case 'w' : res = isalnum(c); break;
	case 'x' : res = isxdigit(c); break;
	case 'z' : res = (c == 0); break; /* deprecated option */
	default: return (cl == c);
	}
	return (islower(cl) ? res : !res);
	}


	static int matchbracketclass (int c, const char p, const char ec) {
	int sig = 1;
	if (*(p+1) == '^') {
	sig = 0;
	p++; /* skip the `^' */
	}
	while (++p < ec) {
	if (*p == L_ESC) {
	p++;
	if (match_class(c, uchar(*p)))
	return sig;
	}
	else if ((*(p+1) == '-') && (p+2 < ec)) {
	p+=2;
	if (uchar((p-2)) <= c && c <= uchar(p))
	return sig;
	}
	else if (uchar(*p) == c) return sig;
	}
	return !sig;
	}


	static int singlematch (MatchState ms, const char s, const char *p,
	const char *ep) {
	if (s >= ms->src_end)
	return 0;
	else {
	int c = uchar(*s);
	switch (*p) {
	case '.': return 1; /* matches any char */
	case L_ESC: return match_class(c, uchar(*(p+1)));
	case '[': return matchbracketclass(c, p, ep-1);
	default: return (uchar(*p) == c);
	}
	}
	}


	static const char matchbalance (MatchState ms, const char *s,
	const char *p) {
	if (p >= ms->p_end - 1)
	luaL_error(ms->L, "malformed pattern "
	"(missing arguments to " LUA_QL("%%b") ")");
	if (s != p) return NULL;
	else {
	int b = *p;
	int e = *(p+1);
	int cont = 1;
	while (++s < ms->src_end) {
	if (*s == e) {
	if (--cont == 0) return s+1;
	}
	else if (*s == b) cont++;
	}
	}
	return NULL; /* string ends out of balance */
	}


	static const char max_expand (MatchState ms, const char *s,
	const char p, const char ep) {
	ptrdiff_t i = 0; /* counts maximum expand for item */
	while (singlematch(ms, s + i, p, ep))
	i++;
	/* keeps trying to match with the maximum repetitions */
	while (i>=0) {
	const char *res = match(ms, (s+i), ep+1);
	if (res) return res;
	i--; /* else didn't match; reduce 1 repetition to try again */
	}
	return NULL;
	}


	static const char min_expand (MatchState ms, const char *s,
	const char p, const char ep) {
	for (;;) {
	const char *res = match(ms, s, ep+1);
	if (res != NULL)
	return res;
	else if (singlematch(ms, s, p, ep))
	s++; /* try with one more repetition */
	else return NULL;
	}
	}


	static const char start_capture (MatchState ms, const char *s,
	const char *p, int what) {
	const char *res;
	int level = ms->level;
	if (level >= LUA_MAXCAPTURES) luaL_error(ms->L, "too many captures");
	ms->capture[level].init = s;
	ms->capture[level].len = what;
	ms->level = level+1;
	if ((res=match(ms, s, p)) == NULL) /* match failed? */
	ms->level--; /* undo capture */
	return res;
	}


	static const char end_capture (MatchState ms, const char *s,
	const char *p) {
	int l = capture_to_close(ms);
	const char *res;
	ms->capture[l].len = s - ms->capture[l].init; /* close capture */
	if ((res = match(ms, s, p)) == NULL) /* match failed? */
	ms->capture[l].len = CAP_UNFINISHED; /* undo capture */
	return res;
	}


	static const char match_capture (MatchState ms, const char *s, int l) {
	size_t len;
	l = check_capture(ms, l);
	len = ms->capture[l].len;
	if ((size_t)(ms->src_end-s) >= len &&
	memcmp(ms->capture[l].init, s, len) == 0)
	return s+len;
	else return NULL;
	}


	static const char match (MatchState ms, const char s, const char p) {
	if (ms->matchdepth-- == 0)
	luaL_error(ms->L, "pattern too complex");
	init: /* using goto's to optimize tail recursion */
	if (p != ms->p_end) { /* end of pattern? */
	switch (*p) {
	case '(': { /* start capture */
	if ((p + 1) == ')') / position capture? */
	s = start_capture(ms, s, p + 2, CAP_POSITION);
	else
	s = start_capture(ms, s, p + 1, CAP_UNFINISHED);
	break;
	}
	case ')': { /* end capture */
	s = end_capture(ms, s, p + 1);
	break;
	}
	case '$': {
	if ((p + 1) != ms->p_end) /* is the `$' the last char in pattern? */
	goto dflt; /* no; go to default */
	s = (s == ms->src_end) ? s : NULL; /* check end of string */
	break;
	}
	case L_ESC: { /* escaped sequences not in the format class[+?-]? /
	switch (*(p + 1)) {
	case 'b': { /* balanced string? */
	s = matchbalance(ms, s, p + 2);
	if (s != NULL) {
	p += 4; goto init; /* return match(ms, s, p + 4); */
	} /* else fail (s == NULL) */
	break;
	}
	case 'f': { /* frontier? */
	const char *ep; char previous;
	p += 2;
	if (*p != '[')
	luaL_error(ms->L, "missing " LUA_QL("[") " after "
	LUA_QL("%%f") " in pattern");
	ep = classend(ms, p); /* points to what is next */
	previous = (s == ms->src_init) ? '\0' : *(s - 1);
	if (!matchbracketclass(uchar(previous), p, ep - 1) &&
	matchbracketclass(uchar(*s), p, ep - 1)) {
	p = ep; goto init; /* return match(ms, s, ep); */
	}
	s = NULL; /* match failed */
	break;
	}
	case '0': case '1': case '2': case '3':
	case '4': case '5': case '6': case '7':
	case '8': case '9': { /* capture results (%0-%9)? */
	s = match_capture(ms, s, uchar(*(p + 1)));
	if (s != NULL) {
	p += 2; goto init; /* return match(ms, s, p + 2) */
	}
	break;
	}
	default: goto dflt;
	}
	break;
	}
	default: dflt: { /* pattern class plus optional suffix */
	const char ep = classend(ms, p); / points to optional suffix */
	/* does not match at least once? */
	if (!singlematch(ms, s, p, ep)) {
	if (ep == '' \|\| ep == '?' \|\| ep == '-') { /* accept empty? */
	p = ep + 1; goto init; /* return match(ms, s, ep + 1); */
	}
	else /* '+' or no suffix */
	s = NULL; /* fail */
	}
	else { /* matched once */
	switch (ep) { / handle optional suffix */
	case '?': { /* optional */
	const char *res;
	if ((res = match(ms, s + 1, ep + 1)) != NULL)
	s = res;
	else {
	p = ep + 1; goto init; /* else return match(ms, s, ep + 1); */
	}
	break;
	}
	case '+': /* 1 or more repetitions */
	s++; /* 1 match already done */
	- /* FALLTHROUGH */
	+ fallthrough;
	case '': / 0 or more repetitions */
	s = max_expand(ms, s, p, ep);
	break;
	case '-': /* 0 or more repetitions (minimum) */
	s = min_expand(ms, s, p, ep);
	break;
	default: /* no suffix */
	s++; p = ep; goto init; /* return match(ms, s + 1, ep); */
	}
	}
	break;
	}
	}
	}
	ms->matchdepth++;
	return s;
	}



	static const char lmemfind (const char s1, size_t l1,
	const char *s2, size_t l2) {
	if (l2 == 0) return s1; /* empty strings are everywhere */
	else if (l2 > l1) return NULL; /* avoids a negative `l1' */
	else {
	const char init; / to search for a `s2' inside `s1' /
	l2--; /* 1st char will be checked by `memchr' */
	l1 = l1-l2; /* `s2' cannot be found after that */
	while (l1 > 0 && (init = (const char )memchr(s1, s2, l1)) != NULL) {
	init++; /* 1st char is already checked */
	if (memcmp(init, s2+1, l2) == 0)
	return init-1;
	else { /* correct `l1' and `s1' to try again */
	l1 -= init-s1;
	s1 = init;
	}
	}
	return NULL; /* not found */
	}
	}


	static void push_onecapture (MatchState ms, int i, const char s,
	const char *e) {
	if (i >= ms->level) {
	if (i == 0) /* ms->level == 0, too */
	lua_pushlstring(ms->L, s, e - s); /* add whole match */
	else
	luaL_error(ms->L, "invalid capture index");
	}
	else {
	ptrdiff_t l = ms->capture[i].len;
	if (l == CAP_UNFINISHED) luaL_error(ms->L, "unfinished capture");
	if (l == CAP_POSITION)
	lua_pushinteger(ms->L, ms->capture[i].init - ms->src_init + 1);
	else
	lua_pushlstring(ms->L, ms->capture[i].init, l);
	}
	}


	static int push_captures (MatchState ms, const char s, const char *e) {
	int i;
	int nlevels = (ms->level == 0 && s) ? 1 : ms->level;
	luaL_checkstack(ms->L, nlevels, "too many captures");
	for (i = 0; i < nlevels; i++)
	push_onecapture(ms, i, s, e);
	return nlevels; /* number of strings pushed */
	}


	/* check whether pattern has no special characters */
	static int nospecials (const char *p, size_t l) {
	size_t upto = 0;
	do {
	if (strpbrk(p + upto, SPECIALS))
	return 0; /* pattern has a special character */
	upto += strlen(p + upto) + 1; /* may have more after \0 */
	} while (upto <= l);
	return 1; /* no special chars found */
	}


	static int str_find_aux (lua_State *L, int find) {
	size_t ls, lp;
	const char *s = luaL_checklstring(L, 1, &ls);
	const char *p = luaL_checklstring(L, 2, &lp);
	size_t init = posrelat(luaL_optinteger(L, 3, 1), ls);
	if (init < 1) init = 1;
	else if (init > ls + 1) { /* start after string's end? */
	lua_pushnil(L); /* cannot find anything */
	return 1;
	}
	/* explicit request or no special characters? */
	if (find && (lua_toboolean(L, 4) \|\| nospecials(p, lp))) {
	/* do a plain search */
	const char *s2 = lmemfind(s + init - 1, ls - init + 1, p, lp);
	if (s2) {
	lua_pushinteger(L, s2 - s + 1);
	lua_pushinteger(L, s2 - s + lp);
	return 2;
	}
	}
	else {
	MatchState ms;
	const char *s1 = s + init - 1;
	int anchor = (*p == '^');
	if (anchor) {
	p++; lp--; /* skip anchor character */
	}
	ms.L = L;
	ms.matchdepth = MAXCCALLS;
	ms.src_init = s;
	ms.src_end = s + ls;
	ms.p_end = p + lp;
	do {
	const char *res;
	ms.level = 0;
	lua_assert(ms.matchdepth == MAXCCALLS);
	if ((res=match(&ms, s1, p)) != NULL) {
	if (find) {
	lua_pushinteger(L, s1 - s + 1); /* start */
	lua_pushinteger(L, res - s); /* end */
	return push_captures(&ms, NULL, 0) + 2;
	}
	else
	return push_captures(&ms, s1, res);
	}
	} while (s1++ < ms.src_end && !anchor);
	}
	lua_pushnil(L); /* not found */
	return 1;
	}


	static int str_find (lua_State *L) {
	return str_find_aux(L, 1);
	}


	static int str_match (lua_State *L) {
	return str_find_aux(L, 0);
	}


	static int gmatch_aux (lua_State *L) {
	MatchState ms;
	size_t ls, lp;
	const char *s = lua_tolstring(L, lua_upvalueindex(1), &ls);
	const char *p = lua_tolstring(L, lua_upvalueindex(2), &lp);
	const char *src;
	ms.L = L;
	ms.matchdepth = MAXCCALLS;
	ms.src_init = s;
	ms.src_end = s+ls;
	ms.p_end = p + lp;
	for (src = s + (size_t)lua_tointeger(L, lua_upvalueindex(3));
	src <= ms.src_end;
	src++) {
	const char *e;
	ms.level = 0;
	lua_assert(ms.matchdepth == MAXCCALLS);
	if ((e = match(&ms, src, p)) != NULL) {
	lua_Integer newstart = e-s;
	if (e == src) newstart++; /* empty match? go at least one position */
	lua_pushinteger(L, newstart);
	lua_replace(L, lua_upvalueindex(3));
	return push_captures(&ms, src, e);
	}
	}
	return 0; /* not found */
	}


	static int str_gmatch (lua_State *L) {
	luaL_checkstring(L, 1);
	luaL_checkstring(L, 2);
	lua_settop(L, 2);
	lua_pushinteger(L, 0);
	lua_pushcclosure(L, gmatch_aux, 3);
	return 1;
	}


	static void add_s (MatchState ms, luaL_Buffer b, const char *s,
	const char *e) {
	size_t l, i;
	const char *news = lua_tolstring(ms->L, 3, &l);
	for (i = 0; i < l; i++) {
	if (news[i] != L_ESC)
	luaL_addchar(b, news[i]);
	else {
	i++; /* skip ESC */
	if (!isdigit(uchar(news[i]))) {
	if (news[i] != L_ESC)
	luaL_error(ms->L, "invalid use of " LUA_QL("%c")
	" in replacement string", L_ESC);
	luaL_addchar(b, news[i]);
	}
	else if (news[i] == '0')
	luaL_addlstring(b, s, e - s);
	else {
	push_onecapture(ms, news[i] - '1', s, e);
	luaL_addvalue(b); /* add capture to accumulated result */
	}
	}
	}
	}


	static void add_value (MatchState ms, luaL_Buffer b, const char *s,
	const char *e, int tr) {
	lua_State *L = ms->L;
	switch (tr) {
	case LUA_TFUNCTION: {
	int n;
	lua_pushvalue(L, 3);
	n = push_captures(ms, s, e);
	lua_call(L, n, 1);
	break;
	}
	case LUA_TTABLE: {
	push_onecapture(ms, 0, s, e);
	lua_gettable(L, 3);
	break;
	}
	default: { /* LUA_TNUMBER or LUA_TSTRING */
	add_s(ms, b, s, e);
	return;
	}
	}
	if (!lua_toboolean(L, -1)) { /* nil or false? */
	lua_pop(L, 1);
	lua_pushlstring(L, s, e - s); /* keep original text */
	}
	else if (!lua_isstring(L, -1))
	luaL_error(L, "invalid replacement value (a %s)", luaL_typename(L, -1));
	luaL_addvalue(b); /* add result to accumulator */
	}


	static int str_gsub (lua_State *L) {
	size_t srcl, lp;
	const char *src = luaL_checklstring(L, 1, &srcl);
	const char *p = luaL_checklstring(L, 2, &lp);
	int tr = lua_type(L, 3);
	size_t max_s = luaL_optinteger(L, 4, srcl+1);
	int anchor = (*p == '^');
	size_t n = 0;
	MatchState ms;
	luaL_Buffer b;
	luaL_argcheck(L, tr == LUA_TNUMBER \|\| tr == LUA_TSTRING \|\|
	tr == LUA_TFUNCTION \|\| tr == LUA_TTABLE, 3,
	"string/function/table expected");
	luaL_buffinit(L, &b);
	if (anchor) {
	p++; lp--; /* skip anchor character */
	}
	ms.L = L;
	ms.matchdepth = MAXCCALLS;
	ms.src_init = src;
	ms.src_end = src+srcl;
	ms.p_end = p + lp;
	while (n < max_s) {
	const char *e;
	ms.level = 0;
	lua_assert(ms.matchdepth == MAXCCALLS);
	e = match(&ms, src, p);
	if (e) {
	n++;
	add_value(&ms, &b, src, e, tr);
	}
	if (e && e>src) /* non empty match? */
	src = e; /* skip it */
	else if (src < ms.src_end)
	luaL_addchar(&b, *src++);
	else break;
	if (anchor) break;
	}
	luaL_addlstring(&b, src, ms.src_end-src);
	luaL_pushresult(&b);
	lua_pushinteger(L, n); /* number of substitutions */
	return 2;
	}

	/* }====================================================== */



	/*
	** {======================================================
	** STRING FORMAT
	** =======================================================
	*/

	/*
	** LUA_INTFRMLEN is the length modifier for integer conversions in
	** 'string.format'; LUA_INTFRM_T is the integer type corresponding to
	** the previous length
	*/
	#if !defined(LUA_INTFRMLEN) /* { */
	#if defined(LUA_USE_LONGLONG)

	#define LUA_INTFRMLEN "ll"
	#define LUA_INTFRM_T long long

	#else

	#define LUA_INTFRMLEN "l"
	#define LUA_INTFRM_T long

	#endif
	#endif /* } */


	/*
	** LUA_FLTFRMLEN is the length modifier for float conversions in
	** 'string.format'; LUA_FLTFRM_T is the float type corresponding to
	** the previous length
	*/
	#if !defined(LUA_FLTFRMLEN)

	#define LUA_FLTFRMLEN ""
	#define LUA_FLTFRM_T double

	#endif


	/* maximum size of each formatted item (> len(format('%99.99f', -1e308))) */
	#define MAX_ITEM 512
	/* valid flags in a format specification */
	#define FLAGS "-+ #0"
	/*
	** maximum size of each format specification (such as '%-099.99d')
	** (+10 accounts for %99.99x plus margin of error)
	*/
	#define MAX_FORMAT (sizeof(FLAGS) + sizeof(LUA_INTFRMLEN) + 10)


	static void addquoted (lua_State L, luaL_Buffer b, int arg) {
	size_t l;
	const char *s = luaL_checklstring(L, arg, &l);
	luaL_addchar(b, '"');
	while (l--) {
	if (s == '"' \|\| s == '\\' \|\| *s == '\n') {
	luaL_addchar(b, '\\');
	luaL_addchar(b, *s);
	}
	else if (s == '\0' \|\| iscntrl(uchar(s))) {
	char buff[10];
	if (!isdigit(uchar(*(s+1))))
	snprintf(buff, sizeof(buff), "\\%d", (int)uchar(*s));
	else
	snprintf(buff, sizeof(buff), "\\%03d", (int)uchar(*s));
	luaL_addstring(b, buff);
	}
	else
	luaL_addchar(b, *s);
	s++;
	}
	luaL_addchar(b, '"');
	}

	static const char scanformat (lua_State L, const char strfrmt, char form) {
	const char *p = strfrmt;
	while (p != '\0' && strchr(FLAGS, p) != NULL) p++; /* skip flags */
	if ((size_t)(p - strfrmt) >= sizeof(FLAGS)/sizeof(char))
	luaL_error(L, "invalid format (repeated flags)");
	if (isdigit(uchar(p))) p++; / skip width */
	if (isdigit(uchar(p))) p++; / (2 digits at most) */
	if (*p == '.') {
	p++;
	if (isdigit(uchar(p))) p++; / skip precision */
	if (isdigit(uchar(p))) p++; / (2 digits at most) */
	}
	if (isdigit(uchar(*p)))
	luaL_error(L, "invalid format (width or precision too long)");
	*(form++) = '%';
	memcpy(form, strfrmt, (p - strfrmt + 1) * sizeof(char));
	form += p - strfrmt + 1;
	*form = '\0';
	return p;
	}


	/*
	** add length modifier into formats
	*/
	static void addlenmod (char form, const char lenmod, size_t size) {
	size_t l = strlen(form);
	size_t lm = strlen(lenmod);
	char spec = form[l - 1];
	strlcpy(form + l - 1, lenmod, size - (l - 1));
	form[l + lm - 1] = spec;
	form[l + lm] = '\0';
	}


	static int str_format (lua_State *L) {
	int top = lua_gettop(L);
	int arg = 1;
	size_t sfl;
	const char *strfrmt = luaL_checklstring(L, arg, &sfl);
	const char *strfrmt_end = strfrmt+sfl;
	luaL_Buffer b;
	luaL_buffinit(L, &b);
	while (strfrmt < strfrmt_end) {
	if (*strfrmt != L_ESC)
	luaL_addchar(&b, *strfrmt++);
	else if (*++strfrmt == L_ESC)
	luaL_addchar(&b, strfrmt++); / %% */
	else { /* format item */
	char form[MAX_FORMAT]; /* to store the format (`%...') */
	char buff = luaL_prepbuffsize(&b, MAX_ITEM); / to put formatted item */
	int nb = 0; /* number of bytes in added item */
	if (++arg > top)
	luaL_argerror(L, arg, "no value");
	strfrmt = scanformat(L, strfrmt, form);
	switch (*strfrmt++) {
	case 'c': {
	nb = str_sprintf(buff, form, luaL_checkint(L, arg));
	break;
	}
	case 'd': case 'i': {
	lua_Number n = luaL_checknumber(L, arg);
	LUA_INTFRM_T ni = (LUA_INTFRM_T)n;
	lua_Number diff = n - (lua_Number)ni;
	luaL_argcheck(L, -1 < diff && diff < 1, arg,
	"not a number in proper range");
	addlenmod(form, LUA_INTFRMLEN, MAX_FORMAT);
	nb = str_sprintf(buff, form, ni);
	break;
	}
	case 'o': case 'u': case 'x': case 'X': {
	lua_Number n = luaL_checknumber(L, arg);
	unsigned LUA_INTFRM_T ni = (unsigned LUA_INTFRM_T)n;
	lua_Number diff = n - (lua_Number)ni;
	luaL_argcheck(L, -1 < diff && diff < 1, arg,
	"not a non-negative number in proper range");
	addlenmod(form, LUA_INTFRMLEN, MAX_FORMAT);
	nb = str_sprintf(buff, form, ni);
	break;
	}
	#if defined(LUA_USE_FLOAT_FORMATS)
	case 'e': case 'E': case 'f':
	#if defined(LUA_USE_AFORMAT)
	case 'a': case 'A':
	#endif
	case 'g': case 'G': {
	addlenmod(form, LUA_FLTFRMLEN, MAX_FORMAT);
	nb = str_sprintf(buff, form, (LUA_FLTFRM_T)luaL_checknumber(L, arg));
	break;
	}
	#endif
	case 'q': {
	addquoted(L, &b, arg);
	break;
	}
	case 's': {
	size_t l;
	const char *s = luaL_tolstring(L, arg, &l);
	if (!strchr(form, '.') && l >= 100) {
	/* no precision and string is too long to be formatted;
	keep original string */
	luaL_addvalue(&b);
	break;
	}
	else {
	nb = str_sprintf(buff, form, s);
	lua_pop(L, 1); /* remove result from 'luaL_tolstring' */
	break;
	}
	}
	default: { /* also treat cases `pnLlh' */
	return luaL_error(L, "invalid option " LUA_QL("%%%c") " to "
	LUA_QL("format"), *(strfrmt - 1));
	}
	}
	luaL_addsize(&b, nb);
	}
	}
	luaL_pushresult(&b);
	return 1;
	}

	/* }====================================================== */


	static const luaL_Reg strlib[] = {
	{"byte", str_byte},
	{"char", str_char},
	#if defined(LUA_USE_DUMP)
	{"dump", str_dump},
	#endif
	{"find", str_find},
	{"format", str_format},
	{"gmatch", str_gmatch},
	{"gsub", str_gsub},
	{"len", str_len},
	{"lower", str_lower},
	{"match", str_match},
	{"rep", str_rep},
	{"reverse", str_reverse},
	{"sub", str_sub},
	{"upper", str_upper},
	{NULL, NULL}
	};


	static void createmetatable (lua_State *L) {
	lua_createtable(L, 0, 1); /* table to be metatable for strings */
	lua_pushliteral(L, ""); /* dummy string */
	lua_pushvalue(L, -2); /* copy table */
	lua_setmetatable(L, -2); /* set table as metatable for strings */
	lua_pop(L, 1); /* pop dummy string */
	lua_pushvalue(L, -2); /* get string library */
	lua_setfield(L, -2, "__index"); /* metatable.__index = string */
	lua_pop(L, 1); /* pop metatable */
	}


	/*
	** Open string library
	*/
	LUAMOD_API int luaopen_string (lua_State *L) {
	luaL_newlib(L, strlib);
	createmetatable(L);
	return 1;
	}

	#if defined(_KERNEL)

	EXPORT_SYMBOL(luaopen_string);

	#endif
	/* END CSTYLED */
	diff --git a/sys/contrib/openzfs/module/lua/ltable.c b/sys/contrib/openzfs/module/lua/ltable.c
	index f60418721bef..f6872babc6e7 100644
	--- a/sys/contrib/openzfs/module/lua/ltable.c
	+++ b/sys/contrib/openzfs/module/lua/ltable.c
	@@ -1,592 +1,592 @@
	/* BEGIN CSTYLED */
	/*
	** $Id: ltable.c,v 2.72.1.1 2013/04/12 18:48:47 roberto Exp $
	** Lua tables (hash)
	** See Copyright Notice in lua.h
	*/


	/*
	** Implementation of tables (aka arrays, objects, or hash tables).
	** Tables keep its elements in two parts: an array part and a hash part.
	** Non-negative integer keys are all candidates to be kept in the array
	** part. The actual size of the array is the largest `n' such that at
	** least half the slots between 0 and n are in use.
	** Hash uses a mix of chained scatter table with Brent's variation.
	** A main invariant of these tables is that, if an element is not
	** in its main position (i.e. the `original' position that its hash gives
	** to it), then the colliding element is in its own main position.
	** Hence even when the load factor reaches 100%, performance remains good.
	*/


	#define ltable_c
	#define LUA_CORE

	#include <sys/lua/lua.h>

	#include "ldebug.h"
	#include "ldo.h"
	#include "lgc.h"
	#include "lmem.h"
	#include "lobject.h"
	#include "lstate.h"
	#include "lstring.h"
	#include "ltable.h"
	#include "lvm.h"


	/*
	** max size of array part is 2^MAXBITS
	*/
	#if LUAI_BITSINT >= 32
	#define MAXBITS 30
	#else
	#define MAXBITS (LUAI_BITSINT-2)
	#endif

	#define MAXASIZE (1 << MAXBITS)


	#define hashpow2(t,n) (gnode(t, lmod((n), sizenode(t))))

	#define hashstr(t,str) hashpow2(t, (str)->tsv.hash)
	#define hashboolean(t,p) hashpow2(t, p)


	/*
	** for some types, it is better to avoid modulus by power of 2, as
	** they tend to have many 2 factors.
	*/
	#define hashmod(t,n) (gnode(t, ((n) % ((sizenode(t)-1)\|1))))


	#define hashpointer(t,p) hashmod(t, IntPoint(p))


	#define dummynode (&dummynode_)

	#define isdummy(n) ((n) == dummynode)

	static const Node dummynode_ = {
	{NILCONSTANT}, /* value */
	{{NILCONSTANT, NULL}} /* key */
	};


	/*
	** hash for lua_Numbers
	*/
	static Node hashnum (const Table t, lua_Number n) {
	int i;
	luai_hashnum(i, n);
	if (i < 0) {
	if (cast(unsigned int, i) == 0u - i) /* use unsigned to avoid overflows */
	i = 0; /* handle INT_MIN */
	i = -i; /* must be a positive value */
	}
	return hashmod(t, i);
	}



	/*
	** returns the `main' position of an element in a table (that is, the index
	** of its hash value)
	*/
	static Node mainposition (const Table t, const TValue *key) {
	switch (ttype(key)) {
	case LUA_TNUMBER:
	return hashnum(t, nvalue(key));
	case LUA_TLNGSTR: {
	TString *s = rawtsvalue(key);
	if (s->tsv.extra == 0) { /* no hash? */
	s->tsv.hash = luaS_hash(getstr(s), s->tsv.len, s->tsv.hash);
	s->tsv.extra = 1; /* now it has its hash */
	}
	return hashstr(t, rawtsvalue(key));
	}
	case LUA_TSHRSTR:
	return hashstr(t, rawtsvalue(key));
	case LUA_TBOOLEAN:
	return hashboolean(t, bvalue(key));
	case LUA_TLIGHTUSERDATA:
	return hashpointer(t, pvalue(key));
	case LUA_TLCF:
	return hashpointer(t, fvalue(key));
	default:
	return hashpointer(t, gcvalue(key));
	}
	}


	/*
	** returns the index for `key' if `key' is an appropriate key to live in
	** the array part of the table, -1 otherwise.
	*/
	static int arrayindex (const TValue *key) {
	if (ttisnumber(key)) {
	lua_Number n = nvalue(key);
	int k;
	lua_number2int(k, n);
	if (luai_numeq(cast_num(k), n))
	return k;
	}
	return -1; /* `key' did not match some condition */
	}


	/*
	** returns the index of a `key' for table traversals. First goes all
	** elements in the array part, then elements in the hash part. The
	** beginning of a traversal is signaled by -1.
	*/
	static int findindex (lua_State L, Table t, StkId key) {
	int i;
	if (ttisnil(key)) return -1; /* first iteration */
	i = arrayindex(key);
	if (0 < i && i <= t->sizearray) /* is `key' inside array part? */
	return i-1; /* yes; that's the index (corrected to C) */
	else {
	Node *n = mainposition(t, key);
	for (;;) { /* check whether `key' is somewhere in the chain */
	/* key may be dead already, but it is ok to use it in `next' */
	if (luaV_rawequalobj(gkey(n), key) \|\|
	(ttisdeadkey(gkey(n)) && iscollectable(key) &&
	deadvalue(gkey(n)) == gcvalue(key))) {
	i = cast_int(n - gnode(t, 0)); /* key index in hash table */
	/* hash elements are numbered after array ones */
	return i + t->sizearray;
	}
	else n = gnext(n);
	if (n == NULL)
	luaG_runerror(L, "invalid key to " LUA_QL("next")); /* key not found */
	}
	}
	}


	int luaH_next (lua_State L, Table t, StkId key) {
	int i = findindex(L, t, key); /* find original element */
	for (i++; i < t->sizearray; i++) { /* try first array part */
	if (!ttisnil(&t->array[i])) { /* a non-nil value? */
	setnvalue(key, cast_num(i+1));
	setobj2s(L, key+1, &t->array[i]);
	return 1;
	}
	}
	for (i -= t->sizearray; i < sizenode(t); i++) { /* then hash part */
	if (!ttisnil(gval(gnode(t, i)))) { /* a non-nil value? */
	setobj2s(L, key, gkey(gnode(t, i)));
	setobj2s(L, key+1, gval(gnode(t, i)));
	return 1;
	}
	}
	return 0; /* no more elements */
	}


	/*
	** {=============================================================
	** Rehash
	** ==============================================================
	*/


	static int computesizes (int nums[], int *narray) {
	int i;
	int twotoi; /* 2^i */
	int a = 0; /* number of elements smaller than 2^i */
	int na = 0; /* number of elements to go to array part */
	int n = 0; /* optimal size for array part */
	for (i = 0, twotoi = 1; twotoi/2 < narray; i++, twotoi = 2) {
	if (nums[i] > 0) {
	a += nums[i];
	if (a > twotoi/2) { /* more than half elements present? */
	n = twotoi; /* optimal size (till now) */
	na = a; /* all elements smaller than n will go to array part */
	}
	}
	if (a == narray) break; / all elements already counted */
	}
	*narray = n;
	lua_assert(narray/2 <= na && na <= narray);
	return na;
	}


	static int countint (const TValue key, int nums) {
	int k = arrayindex(key);
	if (0 < k && k <= MAXASIZE) { /* is `key' an appropriate array index? */
	nums[luaO_ceillog2(k)]++; /* count as such */
	return 1;
	}
	else
	return 0;
	}


	static int numusearray (const Table t, int nums) {
	int lg;
	int ttlg; /* 2^lg */
	int ause = 0; /* summation of `nums' */
	int i = 1; /* count to traverse all array keys */
	for (lg=0, ttlg=1; lg<=MAXBITS; lg++, ttlg=2) { / for each slice */
	int lc = 0; /* counter */
	int lim = ttlg;
	if (lim > t->sizearray) {
	lim = t->sizearray; /* adjust upper limit */
	if (i > lim)
	break; /* no more elements to count */
	}
	/* count elements in range (2^(lg-1), 2^lg] */
	for (; i <= lim; i++) {
	if (!ttisnil(&t->array[i-1]))
	lc++;
	}
	nums[lg] += lc;
	ause += lc;
	}
	return ause;
	}


	static int numusehash (const Table t, int nums, int *pnasize) {
	int totaluse = 0; /* total number of elements */
	int ause = 0; /* summation of `nums' */
	int i = sizenode(t);
	while (i--) {
	Node *n = &t->node[i];
	if (!ttisnil(gval(n))) {
	ause += countint(gkey(n), nums);
	totaluse++;
	}
	}
	*pnasize += ause;
	return totaluse;
	}


	static void setarrayvector (lua_State L, Table t, int size) {
	int i;
	luaM_reallocvector(L, t->array, t->sizearray, size, TValue);
	for (i=t->sizearray; i<size; i++)
	setnilvalue(&t->array[i]);
	t->sizearray = size;
	}


	static void setnodevector (lua_State L, Table t, int size) {
	int lsize;
	if (size == 0) { /* no elements to hash part? */
	t->node = cast(Node , dummynode); / use common `dummynode' */
	lsize = 0;
	}
	else {
	int i;
	lsize = luaO_ceillog2(size);
	if (lsize > MAXBITS)
	luaG_runerror(L, "table overflow");
	size = twoto(lsize);
	t->node = luaM_newvector(L, size, Node);
	for (i=0; i<size; i++) {
	Node *n = gnode(t, i);
	gnext(n) = NULL;
	setnilvalue(gkey(n));
	setnilvalue(gval(n));
	}
	}
	t->lsizenode = cast_byte(lsize);
	t->lastfree = gnode(t, size); /* all positions are free */
	}


	void luaH_resize (lua_State L, Table t, int nasize, int nhsize) {
	int i;
	int oldasize = t->sizearray;
	int oldhsize = t->lsizenode;
	Node nold = t->node; / save old hash ... */
	if (nasize > oldasize) /* array part must grow? */
	setarrayvector(L, t, nasize);
	/* create new hash part with appropriate size */
	setnodevector(L, t, nhsize);
	if (nasize < oldasize) { /* array part must shrink? */
	t->sizearray = nasize;
	/* re-insert elements from vanishing slice */
	for (i=nasize; i<oldasize; i++) {
	if (!ttisnil(&t->array[i]))
	luaH_setint(L, t, i + 1, &t->array[i]);
	}
	/* shrink array */
	luaM_reallocvector(L, t->array, oldasize, nasize, TValue);
	}
	/* re-insert elements from hash part */
	for (i = twoto(oldhsize) - 1; i >= 0; i--) {
	Node *old = nold+i;
	if (!ttisnil(gval(old))) {
	/* doesn't need barrier/invalidate cache, as entry was
	already present in the table */
	setobjt2t(L, luaH_set(L, t, gkey(old)), gval(old));
	}
	}
	if (!isdummy(nold))
	luaM_freearray(L, nold, cast(size_t, twoto(oldhsize))); /* free old array */
	}


	void luaH_resizearray (lua_State L, Table t, int nasize) {
	int nsize = isdummy(t->node) ? 0 : sizenode(t);
	luaH_resize(L, t, nasize, nsize);
	}


	static void rehash (lua_State L, Table t, const TValue *ek) {
	int nasize, na;
	int nums[MAXBITS+1]; /* nums[i] = number of keys with 2^(i-1) < k <= 2^i */
	int i;
	int totaluse;
	for (i=0; i<=MAXBITS; i++) nums[i] = 0; /* reset counts */
	nasize = numusearray(t, nums); /* count keys in array part */
	totaluse = nasize; /* all those keys are integer keys */
	totaluse += numusehash(t, nums, &nasize); /* count keys in hash part */
	/* count extra key */
	nasize += countint(ek, nums);
	totaluse++;
	/* compute new size for array part */
	na = computesizes(nums, &nasize);
	/* resize the table to new computed sizes */
	luaH_resize(L, t, nasize, totaluse - na);
	}



	/*
	** }=============================================================
	*/


	Table luaH_new (lua_State L) {
	Table *t = &luaC_newobj(L, LUA_TTABLE, sizeof(Table), NULL, 0)->h;
	t->metatable = NULL;
	t->flags = cast_byte(~0);
	t->array = NULL;
	t->sizearray = 0;
	setnodevector(L, t, 0);
	return t;
	}


	void luaH_free (lua_State L, Table t) {
	if (!isdummy(t->node))
	luaM_freearray(L, t->node, cast(size_t, sizenode(t)));
	luaM_freearray(L, t->array, t->sizearray);
	luaM_free(L, t);
	}


	static Node getfreepos (Table t) {
	while (t->lastfree > t->node) {
	t->lastfree--;
	if (ttisnil(gkey(t->lastfree)))
	return t->lastfree;
	}
	return NULL; /* could not find a free place */
	}



	/*
	** inserts a new key into a hash table; first, check whether key's main
	** position is free. If not, check whether colliding node is in its main
	** position or not: if it is not, move colliding node to an empty place and
	** put new key in its main position; otherwise (colliding node is in its main
	** position), new key goes to an empty position.
	*/
	TValue luaH_newkey (lua_State L, Table t, const TValue key) {
	Node *mp;
	if (ttisnil(key)) luaG_runerror(L, "table index is nil");
	#if defined LUA_HAS_FLOAT_NUMBERS
	else if (ttisnumber(key) && luai_numisnan(L, nvalue(key)))
	luaG_runerror(L, "table index is NaN");
	#endif
	mp = mainposition(t, key);
	if (!ttisnil(gval(mp)) \|\| isdummy(mp)) { /* main position is taken? */
	Node *othern;
	Node n = getfreepos(t); / get a free place */
	if (n == NULL) { /* cannot find a free place? */
	rehash(L, t, key); /* grow table */
	/* whatever called 'newkey' take care of TM cache and GC barrier */
	return luaH_set(L, t, key); /* insert key into grown table */
	}
	lua_assert(!isdummy(n));
	othern = mainposition(t, gkey(mp));
	if (othern != mp) { /* is colliding node out of its main position? */
	/* yes; move colliding node into free position */
	while (gnext(othern) != mp) othern = gnext(othern); /* find previous */
	gnext(othern) = n; /* redo the chain with `n' in place of `mp' */
	n = mp; /* copy colliding node into free pos. (mp->next also goes) */
	gnext(mp) = NULL; /* now `mp' is free */
	setnilvalue(gval(mp));
	}
	else { /* colliding node is in its own main position */
	/* new node will go into free position */
	gnext(n) = gnext(mp); /* chain new position */
	gnext(mp) = n;
	mp = n;
	}
	}
	setobj2t(L, gkey(mp), key);
	luaC_barrierback(L, obj2gco(t), key);
	lua_assert(ttisnil(gval(mp)));
	return gval(mp);
	}


	/*
	** search function for integers
	*/
	const TValue luaH_getint (Table t, int key) {
	/* (1 <= key && key <= t->sizearray) */
	if (cast(unsigned int, key-1) < cast(unsigned int, t->sizearray))
	return &t->array[key-1];
	else {
	lua_Number nk = cast_num(key);
	Node *n = hashnum(t, nk);
	do { /* check whether `key' is somewhere in the chain */
	if (ttisnumber(gkey(n)) && luai_numeq(nvalue(gkey(n)), nk))
	return gval(n); /* that's it */
	else n = gnext(n);
	} while (n);
	return luaO_nilobject;
	}
	}


	/*
	** search function for short strings
	*/
	const TValue luaH_getstr (Table t, TString *key) {
	Node *n = hashstr(t, key);
	lua_assert(key->tsv.tt == LUA_TSHRSTR);
	do { /* check whether `key' is somewhere in the chain */
	if (ttisshrstring(gkey(n)) && eqshrstr(rawtsvalue(gkey(n)), key))
	return gval(n); /* that's it */
	else n = gnext(n);
	} while (n);
	return luaO_nilobject;
	}


	/*
	** main search function
	*/
	const TValue luaH_get (Table t, const TValue *key) {
	switch (ttype(key)) {
	case LUA_TSHRSTR: return luaH_getstr(t, rawtsvalue(key));
	case LUA_TNIL: return luaO_nilobject;
	case LUA_TNUMBER: {
	int k;
	lua_Number n = nvalue(key);
	lua_number2int(k, n);
	if (luai_numeq(cast_num(k), n)) /* index is int? */
	return luaH_getint(t, k); /* use specialized version */
	/* else go through */
	}
	- /* FALLTHROUGH */
	+ fallthrough;
	default: {
	Node *n = mainposition(t, key);
	do { /* check whether `key' is somewhere in the chain */
	if (luaV_rawequalobj(gkey(n), key))
	return gval(n); /* that's it */
	else n = gnext(n);
	} while (n);
	return luaO_nilobject;
	}
	}
	}


	/*
	** beware: when using this function you probably need to check a GC
	** barrier and invalidate the TM cache.
	*/
	TValue luaH_set (lua_State L, Table t, const TValue key) {
	const TValue *p = luaH_get(t, key);
	if (p != luaO_nilobject)
	return cast(TValue *, p);
	else return luaH_newkey(L, t, key);
	}


	void luaH_setint (lua_State L, Table t, int key, TValue *value) {
	const TValue *p = luaH_getint(t, key);
	TValue *cell;
	if (p != luaO_nilobject)
	cell = cast(TValue *, p);
	else {
	TValue k;
	setnvalue(&k, cast_num(key));
	cell = luaH_newkey(L, t, &k);
	}
	setobj2t(L, cell, value);
	}


	static int unbound_search (Table *t, unsigned int j) {
	unsigned int i = j; /* i is zero or a present index */
	j++;
	/* find `i' and `j' such that i is present and j is not */
	while (!ttisnil(luaH_getint(t, j))) {
	i = j;
	j *= 2;
	if (j > cast(unsigned int, MAX_INT)) { /* overflow? */
	/* table was built with bad purposes: resort to linear search */
	i = 1;
	while (!ttisnil(luaH_getint(t, i))) i++;
	return i - 1;
	}
	}
	/* now do a binary search between them */
	while (j - i > 1) {
	unsigned int m = (i+j)/2;
	if (ttisnil(luaH_getint(t, m))) j = m;
	else i = m;
	}
	return i;
	}


	/*
	** Try to find a boundary in table `t'. A `boundary' is an integer index
	** such that t[i] is non-nil and t[i+1] is nil (and 0 if t[1] is nil).
	*/
	int luaH_getn (Table *t) {
	unsigned int j = t->sizearray;
	if (j > 0 && ttisnil(&t->array[j - 1])) {
	/* there is a boundary in the array part: (binary) search for it */
	unsigned int i = 0;
	while (j - i > 1) {
	unsigned int m = (i+j)/2;
	if (ttisnil(&t->array[m - 1])) j = m;
	else i = m;
	}
	return i;
	}
	/* else must find a boundary in hash part */
	else if (isdummy(t->node)) /* hash part is empty? */
	return j; /* that is easy... */
	else return unbound_search(t, j);
	}



	#if defined(LUA_DEBUG)

	Node luaH_mainposition (const Table t, const TValue *key) {
	return mainposition(t, key);
	}

	int luaH_isdummy (Node *n) { return isdummy(n); }

	#endif
	/* END CSTYLED */
	diff --git a/sys/contrib/openzfs/module/nvpair/nvpair.c b/sys/contrib/openzfs/module/nvpair/nvpair.c
	index 5f427c8cf2e7..9834dedd859d 100644
	--- a/sys/contrib/openzfs/module/nvpair/nvpair.c
	+++ b/sys/contrib/openzfs/module/nvpair/nvpair.c
	@@ -1,3788 +1,3792 @@
	/*
	* 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) 2000, 2010, Oracle and/or its affiliates. All rights reserved.
	* Copyright (c) 2015, 2017 by Delphix. All rights reserved.
	* Copyright 2018 RackTop Systems.
	*/

	/*
	* Links to Illumos.org for more information on Interface Libraries:
	* [1] https://illumos.org/man/3lib/libnvpair
	* [2] https://illumos.org/man/3nvpair/nvlist_alloc
	* [3] https://illumos.org/man/9f/nvlist_alloc
	* [4] https://illumos.org/man/9f/nvlist_next_nvpair
	* [5] https://illumos.org/man/9f/nvpair_value_byte
	*/

	#include <sys/debug.h>
	#include <sys/isa_defs.h>
	#include <sys/nvpair.h>
	#include <sys/nvpair_impl.h>
	#include <sys/types.h>
	#include <sys/param.h>
	#include <sys/strings.h>
	#include <rpc/xdr.h>
	#include <sys/mod.h>

	#if defined(_KERNEL)
	#include <sys/sunddi.h>
	#include <sys/sysmacros.h>
	#else
	#include <stdarg.h>
	#include <stdlib.h>
	#include <stddef.h>
	#endif

	#define skip_whitespace(p) while (((p) == ' ') \|\| ((p) == '\t')) p++

	/*
	* nvpair.c - Provides kernel & userland interfaces for manipulating
	* name-value pairs.
	*
	* Overview Diagram
	*
	* +--------------+
	* \| nvlist_t \|
	* \|--------------\|
	* \| nvl_version \|
	* \| nvl_nvflag \|
	* \| nvl_priv -+-+
	* \| nvl_flag \| \|
	* \| nvl_pad \| \|
	* +--------------+ \|
	* V
	* +--------------+ last i_nvp in list
	* \| nvpriv_t \| +--------------------->
	* \|--------------\| \|
	* +--+- nvp_list \| \| +------------+
	* \| \| nvp_last -+--+ + nv_alloc_t \|
	* \| \| nvp_curr \| \|------------\|
	* \| \| nvp_nva -+----> \| nva_ops \|
	* \| \| nvp_stat \| \| nva_arg \|
	* \| +--------------+ +------------+
	* \|
	* +-------+
	* V
	* +---------------------+ +-------------------+
	* \| i_nvp_t \| +-->\| i_nvp_t \| +-->
	* \|---------------------\| \| \|-------------------\| \|
	* \| nvi_next -+--+ \| nvi_next -+--+
	* \| nvi_prev (NULL) \| <----+ nvi_prev \|
	* \| . . . . . . . . . . \| \| . . . . . . . . . \|
	* \| nvp (nvpair_t) \| \| nvp (nvpair_t) \|
	* \| - nvp_size \| \| - nvp_size \|
	* \| - nvp_name_sz \| \| - nvp_name_sz \|
	* \| - nvp_value_elem \| \| - nvp_value_elem \|
	* \| - nvp_type \| \| - nvp_type \|
	* \| - data ... \| \| - data ... \|
	* +---------------------+ +-------------------+
	*
	*
	*
	* +---------------------+ +---------------------+
	* \| i_nvp_t \| +--> +-->\| i_nvp_t (last) \|
	* \|---------------------\| \| \| \|---------------------\|
	* \| nvi_next -+--+ ... --+ \| nvi_next (NULL) \|
	* <-+- nvi_prev \|<-- ... <----+ nvi_prev \|
	* \| . . . . . . . . . \| \| . . . . . . . . . \|
	* \| nvp (nvpair_t) \| \| nvp (nvpair_t) \|
	* \| - nvp_size \| \| - nvp_size \|
	* \| - nvp_name_sz \| \| - nvp_name_sz \|
	* \| - nvp_value_elem \| \| - nvp_value_elem \|
	* \| - DATA_TYPE_NVLIST \| \| - nvp_type \|
	* \| - data (embedded) \| \| - data ... \|
	* \| nvlist name \| +---------------------+
	* \| +--------------+ \|
	* \| \| nvlist_t \| \|
	* \| \|--------------\| \|
	* \| \| nvl_version \| \|
	* \| \| nvl_nvflag \| \|
	* \| \| nvl_priv --+---+---->
	* \| \| nvl_flag \| \|
	* \| \| nvl_pad \| \|
	* \| +--------------+ \|
	* +---------------------+
	*
	*
	* N.B. nvpair_t may be aligned on 4 byte boundary, so +4 will
	* allow value to be aligned on 8 byte boundary
	*
	* name_len is the length of the name string including the null terminator
	* so it must be >= 1
	*/
	#define NVP_SIZE_CALC(name_len, data_len) \
	(NV_ALIGN((sizeof (nvpair_t)) + name_len) + NV_ALIGN(data_len))

	static int i_get_value_size(data_type_t type, const void *data, uint_t nelem);
	static int nvlist_add_common(nvlist_t nvl, const char name, data_type_t type,
	uint_t nelem, const void *data);

	#define NV_STAT_EMBEDDED 0x1
	#define EMBEDDED_NVL(nvp) ((nvlist_t )(void )NVP_VALUE(nvp))
	#define EMBEDDED_NVL_ARRAY(nvp) ((nvlist_t *)(void )NVP_VALUE(nvp))

	#define NVP_VALOFF(nvp) (NV_ALIGN(sizeof (nvpair_t) + (nvp)->nvp_name_sz))
	#define NVPAIR2I_NVP(nvp) \
	((i_nvp_t *)((size_t)(nvp) - offsetof(i_nvp_t, nvi_nvp)))

	#ifdef _KERNEL
	int nvpair_max_recursion = 20;
	#else
	int nvpair_max_recursion = 100;
	#endif

	uint64_t nvlist_hashtable_init_size = (1 << 4);

	int
	nv_alloc_init(nv_alloc_t nva, const nv_alloc_ops_t nvo, /* args */ ...)
	{
	va_list valist;
	int err = 0;

	nva->nva_ops = nvo;
	nva->nva_arg = NULL;

	va_start(valist, nvo);
	if (nva->nva_ops->nv_ao_init != NULL)
	err = nva->nva_ops->nv_ao_init(nva, valist);
	va_end(valist);

	return (err);
	}

	void
	nv_alloc_reset(nv_alloc_t *nva)
	{
	if (nva->nva_ops->nv_ao_reset != NULL)
	nva->nva_ops->nv_ao_reset(nva);
	}

	void
	nv_alloc_fini(nv_alloc_t *nva)
	{
	if (nva->nva_ops->nv_ao_fini != NULL)
	nva->nva_ops->nv_ao_fini(nva);
	}

	nv_alloc_t *
	nvlist_lookup_nv_alloc(nvlist_t *nvl)
	{
	nvpriv_t *priv;

	if (nvl == NULL \|\|
	(priv = (nvpriv_t *)(uintptr_t)nvl->nvl_priv) == NULL)
	return (NULL);

	return (priv->nvp_nva);
	}

	static void *
	nv_mem_zalloc(nvpriv_t *nvp, size_t size)
	{
	nv_alloc_t *nva = nvp->nvp_nva;
	void *buf;

	if ((buf = nva->nva_ops->nv_ao_alloc(nva, size)) != NULL)
	bzero(buf, size);

	return (buf);
	}

	static void
	nv_mem_free(nvpriv_t nvp, void buf, size_t size)
	{
	nv_alloc_t *nva = nvp->nvp_nva;

	nva->nva_ops->nv_ao_free(nva, buf, size);
	}

	static void
	nv_priv_init(nvpriv_t priv, nv_alloc_t nva, uint32_t stat)
	{
	bzero(priv, sizeof (nvpriv_t));

	priv->nvp_nva = nva;
	priv->nvp_stat = stat;
	}

	static nvpriv_t *
	nv_priv_alloc(nv_alloc_t *nva)
	{
	nvpriv_t *priv;

	/*
	* nv_mem_alloc() cannot called here because it needs the priv
	* argument.
	*/
	if ((priv = nva->nva_ops->nv_ao_alloc(nva, sizeof (nvpriv_t))) == NULL)
	return (NULL);

	nv_priv_init(priv, nva, 0);

	return (priv);
	}

	/*
	* Embedded lists need their own nvpriv_t's. We create a new
	* nvpriv_t using the parameters and allocator from the parent
	* list's nvpriv_t.
	*/
	static nvpriv_t *
	nv_priv_alloc_embedded(nvpriv_t *priv)
	{
	nvpriv_t *emb_priv;

	if ((emb_priv = nv_mem_zalloc(priv, sizeof (nvpriv_t))) == NULL)
	return (NULL);

	nv_priv_init(emb_priv, priv->nvp_nva, NV_STAT_EMBEDDED);

	return (emb_priv);
	}

	static int
	nvt_tab_alloc(nvpriv_t *priv, uint64_t buckets)
	{
	ASSERT3P(priv->nvp_hashtable, ==, NULL);
	ASSERT0(priv->nvp_nbuckets);
	ASSERT0(priv->nvp_nentries);

	i_nvp_t *tab = nv_mem_zalloc(priv, buckets sizeof (i_nvp_t *));
	if (tab == NULL)
	return (ENOMEM);

	priv->nvp_hashtable = tab;
	priv->nvp_nbuckets = buckets;
	return (0);
	}

	static void
	nvt_tab_free(nvpriv_t *priv)
	{
	i_nvp_t **tab = priv->nvp_hashtable;
	if (tab == NULL) {
	ASSERT0(priv->nvp_nbuckets);
	ASSERT0(priv->nvp_nentries);
	return;
	}

	nv_mem_free(priv, tab, priv->nvp_nbuckets * sizeof (i_nvp_t *));

	priv->nvp_hashtable = NULL;
	priv->nvp_nbuckets = 0;
	priv->nvp_nentries = 0;
	}

	static uint32_t
	nvt_hash(const char *p)
	{
	uint32_t g, hval = 0;

	while (*p) {
	hval = (hval << 4) + *p++;
	if ((g = (hval & 0xf0000000)) != 0)
	hval ^= g >> 24;
	hval &= ~g;
	}
	return (hval);
	}

	static boolean_t
	nvt_nvpair_match(nvpair_t nvp1, nvpair_t nvp2, uint32_t nvflag)
	{
	boolean_t match = B_FALSE;
	if (nvflag & NV_UNIQUE_NAME_TYPE) {
	if (strcmp(NVP_NAME(nvp1), NVP_NAME(nvp2)) == 0 &&
	NVP_TYPE(nvp1) == NVP_TYPE(nvp2))
	match = B_TRUE;
	} else {
	ASSERT(nvflag == 0 \|\| nvflag & NV_UNIQUE_NAME);
	if (strcmp(NVP_NAME(nvp1), NVP_NAME(nvp2)) == 0)
	match = B_TRUE;
	}
	return (match);
	}

	static nvpair_t *
	nvt_lookup_name_type(nvlist_t nvl, const char name, data_type_t type)
	{
	nvpriv_t priv = (nvpriv_t )(uintptr_t)nvl->nvl_priv;
	ASSERT(priv != NULL);

	i_nvp_t **tab = priv->nvp_hashtable;

	if (tab == NULL) {
	ASSERT3P(priv->nvp_list, ==, NULL);
	ASSERT0(priv->nvp_nbuckets);
	ASSERT0(priv->nvp_nentries);
	return (NULL);
	} else {
	ASSERT(priv->nvp_nbuckets != 0);
	}

	uint64_t hash = nvt_hash(name);
	uint64_t index = hash & (priv->nvp_nbuckets - 1);

	ASSERT3U(index, <, priv->nvp_nbuckets);
	i_nvp_t *entry = tab[index];

	for (i_nvp_t *e = entry; e != NULL; e = e->nvi_hashtable_next) {
	if (strcmp(NVP_NAME(&e->nvi_nvp), name) == 0 &&
	(type == DATA_TYPE_DONTCARE \|\|
	NVP_TYPE(&e->nvi_nvp) == type))
	return (&e->nvi_nvp);
	}
	return (NULL);
	}

	static nvpair_t *
	nvt_lookup_name(nvlist_t nvl, const char name)
	{
	return (nvt_lookup_name_type(nvl, name, DATA_TYPE_DONTCARE));
	}

	static int
	nvt_resize(nvpriv_t *priv, uint32_t new_size)
	{
	i_nvp_t **tab = priv->nvp_hashtable;

	/*
	* Migrate all the entries from the current table
	* to a newly-allocated table with the new size by
	* re-adjusting the pointers of their entries.
	*/
	uint32_t size = priv->nvp_nbuckets;
	uint32_t new_mask = new_size - 1;
	ASSERT(ISP2(new_size));

	i_nvp_t *new_tab = nv_mem_zalloc(priv, new_size sizeof (i_nvp_t *));
	if (new_tab == NULL)
	return (ENOMEM);

	uint32_t nentries = 0;
	for (uint32_t i = 0; i < size; i++) {
	i_nvp_t next, e = tab[i];

	while (e != NULL) {
	next = e->nvi_hashtable_next;

	uint32_t hash = nvt_hash(NVP_NAME(&e->nvi_nvp));
	uint32_t index = hash & new_mask;

	e->nvi_hashtable_next = new_tab[index];
	new_tab[index] = e;
	nentries++;

	e = next;
	}
	tab[i] = NULL;
	}
	ASSERT3U(nentries, ==, priv->nvp_nentries);

	nvt_tab_free(priv);

	priv->nvp_hashtable = new_tab;
	priv->nvp_nbuckets = new_size;
	priv->nvp_nentries = nentries;

	return (0);
	}

	static boolean_t
	nvt_needs_togrow(nvpriv_t *priv)
	{
	/*
	* Grow only when we have more elements than buckets
	* and the # of buckets doesn't overflow.
	*/
	return (priv->nvp_nentries > priv->nvp_nbuckets &&
	(UINT32_MAX >> 1) >= priv->nvp_nbuckets);
	}

	/*
	* Allocate a new table that's twice the size of the old one,
	* and migrate all the entries from the old one to the new
	* one by re-adjusting their pointers.
	*/
	static int
	nvt_grow(nvpriv_t *priv)
	{
	uint32_t current_size = priv->nvp_nbuckets;
	/* ensure we won't overflow */
	ASSERT3U(UINT32_MAX >> 1, >=, current_size);
	return (nvt_resize(priv, current_size << 1));
	}

	static boolean_t
	nvt_needs_toshrink(nvpriv_t *priv)
	{
	/*
	* Shrink only when the # of elements is less than or
	* equal to 1/4 the # of buckets. Never shrink less than
	* nvlist_hashtable_init_size.
	*/
	ASSERT3U(priv->nvp_nbuckets, >=, nvlist_hashtable_init_size);
	if (priv->nvp_nbuckets == nvlist_hashtable_init_size)
	return (B_FALSE);
	return (priv->nvp_nentries <= (priv->nvp_nbuckets >> 2));
	}

	/*
	* Allocate a new table that's half the size of the old one,
	* and migrate all the entries from the old one to the new
	* one by re-adjusting their pointers.
	*/
	static int
	nvt_shrink(nvpriv_t *priv)
	{
	uint32_t current_size = priv->nvp_nbuckets;
	/* ensure we won't overflow */
	ASSERT3U(current_size, >=, nvlist_hashtable_init_size);
	return (nvt_resize(priv, current_size >> 1));
	}

	static int
	nvt_remove_nvpair(nvlist_t nvl, nvpair_t nvp)
	{
	nvpriv_t priv = (nvpriv_t )(uintptr_t)nvl->nvl_priv;

	if (nvt_needs_toshrink(priv)) {
	int err = nvt_shrink(priv);
	if (err != 0)
	return (err);
	}
	i_nvp_t **tab = priv->nvp_hashtable;

	char *name = NVP_NAME(nvp);
	uint64_t hash = nvt_hash(name);
	uint64_t index = hash & (priv->nvp_nbuckets - 1);

	ASSERT3U(index, <, priv->nvp_nbuckets);
	i_nvp_t *bucket = tab[index];

	for (i_nvp_t prev = NULL, e = bucket;
	e != NULL; prev = e, e = e->nvi_hashtable_next) {
	if (nvt_nvpair_match(&e->nvi_nvp, nvp, nvl->nvl_nvflag)) {
	if (prev != NULL) {
	prev->nvi_hashtable_next =
	e->nvi_hashtable_next;
	} else {
	ASSERT3P(e, ==, bucket);
	tab[index] = e->nvi_hashtable_next;
	}
	e->nvi_hashtable_next = NULL;
	priv->nvp_nentries--;
	break;
	}
	}

	return (0);
	}

	static int
	nvt_add_nvpair(nvlist_t nvl, nvpair_t nvp)
	{
	nvpriv_t priv = (nvpriv_t )(uintptr_t)nvl->nvl_priv;

	/* initialize nvpair table now if it doesn't exist. */
	if (priv->nvp_hashtable == NULL) {
	int err = nvt_tab_alloc(priv, nvlist_hashtable_init_size);
	if (err != 0)
	return (err);
	}

	/*
	* if we don't allow duplicate entries, make sure to
	* unlink any existing entries from the table.
	*/
	if (nvl->nvl_nvflag != 0) {
	int err = nvt_remove_nvpair(nvl, nvp);
	if (err != 0)
	return (err);
	}

	if (nvt_needs_togrow(priv)) {
	int err = nvt_grow(priv);
	if (err != 0)
	return (err);
	}
	i_nvp_t **tab = priv->nvp_hashtable;

	char *name = NVP_NAME(nvp);
	uint64_t hash = nvt_hash(name);
	uint64_t index = hash & (priv->nvp_nbuckets - 1);

	ASSERT3U(index, <, priv->nvp_nbuckets);
	+ // cppcheck-suppress nullPointerRedundantCheck
	i_nvp_t *bucket = tab[index];

	/* insert link at the beginning of the bucket */
	i_nvp_t *new_entry = NVPAIR2I_NVP(nvp);
	ASSERT3P(new_entry->nvi_hashtable_next, ==, NULL);
	new_entry->nvi_hashtable_next = bucket;
	+ // cppcheck-suppress nullPointerRedundantCheck
	tab[index] = new_entry;

	priv->nvp_nentries++;
	return (0);
	}

	static void
	nvlist_init(nvlist_t nvl, uint32_t nvflag, nvpriv_t priv)
	{
	nvl->nvl_version = NV_VERSION;
	nvl->nvl_nvflag = nvflag & (NV_UNIQUE_NAME\|NV_UNIQUE_NAME_TYPE);
	nvl->nvl_priv = (uint64_t)(uintptr_t)priv;
	nvl->nvl_flag = 0;
	nvl->nvl_pad = 0;
	}

	uint_t
	nvlist_nvflag(nvlist_t *nvl)
	{
	return (nvl->nvl_nvflag);
	}

	static nv_alloc_t *
	nvlist_nv_alloc(int kmflag)
	{
	#if defined(_KERNEL)
	switch (kmflag) {
	case KM_SLEEP:
	return (nv_alloc_sleep);
	case KM_NOSLEEP:
	return (nv_alloc_nosleep);
	default:
	return (nv_alloc_pushpage);
	}
	#else
	return (nv_alloc_nosleep);
	#endif /* _KERNEL */
	}

	/*
	* nvlist_alloc - Allocate nvlist.
	*/
	int
	nvlist_alloc(nvlist_t **nvlp, uint_t nvflag, int kmflag)
	{
	return (nvlist_xalloc(nvlp, nvflag, nvlist_nv_alloc(kmflag)));
	}

	int
	nvlist_xalloc(nvlist_t *nvlp, uint_t nvflag, nv_alloc_t nva)
	{
	nvpriv_t *priv;

	if (nvlp == NULL \|\| nva == NULL)
	return (EINVAL);

	if ((priv = nv_priv_alloc(nva)) == NULL)
	return (ENOMEM);

	if ((*nvlp = nv_mem_zalloc(priv,
	NV_ALIGN(sizeof (nvlist_t)))) == NULL) {
	nv_mem_free(priv, priv, sizeof (nvpriv_t));
	return (ENOMEM);
	}

	nvlist_init(*nvlp, nvflag, priv);

	return (0);
	}

	/*
	* nvp_buf_alloc - Allocate i_nvp_t for storing a new nv pair.
	*/
	static nvpair_t *
	nvp_buf_alloc(nvlist_t *nvl, size_t len)
	{
	nvpriv_t priv = (nvpriv_t )(uintptr_t)nvl->nvl_priv;
	i_nvp_t *buf;
	nvpair_t *nvp;
	size_t nvsize;

	/*
	* Allocate the buffer
	*/
	nvsize = len + offsetof(i_nvp_t, nvi_nvp);

	if ((buf = nv_mem_zalloc(priv, nvsize)) == NULL)
	return (NULL);

	nvp = &buf->nvi_nvp;
	nvp->nvp_size = len;

	return (nvp);
	}

	/*
	* nvp_buf_free - de-Allocate an i_nvp_t.
	*/
	static void
	nvp_buf_free(nvlist_t nvl, nvpair_t nvp)
	{
	nvpriv_t priv = (nvpriv_t )(uintptr_t)nvl->nvl_priv;
	size_t nvsize = nvp->nvp_size + offsetof(i_nvp_t, nvi_nvp);

	nv_mem_free(priv, NVPAIR2I_NVP(nvp), nvsize);
	}

	/*
	* nvp_buf_link - link a new nv pair into the nvlist.
	*/
	static void
	nvp_buf_link(nvlist_t nvl, nvpair_t nvp)
	{
	nvpriv_t priv = (nvpriv_t )(uintptr_t)nvl->nvl_priv;
	i_nvp_t *curr = NVPAIR2I_NVP(nvp);

	/* Put element at end of nvlist */
	if (priv->nvp_list == NULL) {
	priv->nvp_list = priv->nvp_last = curr;
	} else {
	curr->nvi_prev = priv->nvp_last;
	priv->nvp_last->nvi_next = curr;
	priv->nvp_last = curr;
	}
	}

	/*
	* nvp_buf_unlink - unlink an removed nvpair out of the nvlist.
	*/
	static void
	nvp_buf_unlink(nvlist_t nvl, nvpair_t nvp)
	{
	nvpriv_t priv = (nvpriv_t )(uintptr_t)nvl->nvl_priv;
	i_nvp_t *curr = NVPAIR2I_NVP(nvp);

	/*
	* protect nvlist_next_nvpair() against walking on freed memory.
	*/
	if (priv->nvp_curr == curr)
	priv->nvp_curr = curr->nvi_next;

	if (curr == priv->nvp_list)
	priv->nvp_list = curr->nvi_next;
	else
	curr->nvi_prev->nvi_next = curr->nvi_next;

	if (curr == priv->nvp_last)
	priv->nvp_last = curr->nvi_prev;
	else
	curr->nvi_next->nvi_prev = curr->nvi_prev;
	}

	/*
	* take a nvpair type and number of elements and make sure the are valid
	*/
	static int
	i_validate_type_nelem(data_type_t type, uint_t nelem)
	{
	switch (type) {
	case DATA_TYPE_BOOLEAN:
	if (nelem != 0)
	return (EINVAL);
	break;
	case DATA_TYPE_BOOLEAN_VALUE:
	case DATA_TYPE_BYTE:
	case DATA_TYPE_INT8:
	case DATA_TYPE_UINT8:
	case DATA_TYPE_INT16:
	case DATA_TYPE_UINT16:
	case DATA_TYPE_INT32:
	case DATA_TYPE_UINT32:
	case DATA_TYPE_INT64:
	case DATA_TYPE_UINT64:
	case DATA_TYPE_STRING:
	case DATA_TYPE_HRTIME:
	case DATA_TYPE_NVLIST:
	#if !defined(_KERNEL)
	case DATA_TYPE_DOUBLE:
	#endif
	if (nelem != 1)
	return (EINVAL);
	break;
	case DATA_TYPE_BOOLEAN_ARRAY:
	case DATA_TYPE_BYTE_ARRAY:
	case DATA_TYPE_INT8_ARRAY:
	case DATA_TYPE_UINT8_ARRAY:
	case DATA_TYPE_INT16_ARRAY:
	case DATA_TYPE_UINT16_ARRAY:
	case DATA_TYPE_INT32_ARRAY:
	case DATA_TYPE_UINT32_ARRAY:
	case DATA_TYPE_INT64_ARRAY:
	case DATA_TYPE_UINT64_ARRAY:
	case DATA_TYPE_STRING_ARRAY:
	case DATA_TYPE_NVLIST_ARRAY:
	/* we allow arrays with 0 elements */
	break;
	default:
	return (EINVAL);
	}
	return (0);
	}

	/*
	* Verify nvp_name_sz and check the name string length.
	*/
	static int
	i_validate_nvpair_name(nvpair_t *nvp)
	{
	if ((nvp->nvp_name_sz <= 0) \|\|
	(nvp->nvp_size < NVP_SIZE_CALC(nvp->nvp_name_sz, 0)))
	return (EFAULT);

	/* verify the name string, make sure its terminated */
	if (NVP_NAME(nvp)[nvp->nvp_name_sz - 1] != '\0')
	return (EFAULT);

	return (strlen(NVP_NAME(nvp)) == nvp->nvp_name_sz - 1 ? 0 : EFAULT);
	}

	static int
	i_validate_nvpair_value(data_type_t type, uint_t nelem, const void *data)
	{
	switch (type) {
	case DATA_TYPE_BOOLEAN_VALUE:
	if ((boolean_t )data != B_TRUE &&
	(boolean_t )data != B_FALSE)
	return (EINVAL);
	break;
	case DATA_TYPE_BOOLEAN_ARRAY: {
	int i;

	for (i = 0; i < nelem; i++)
	if (((boolean_t *)data)[i] != B_TRUE &&
	((boolean_t *)data)[i] != B_FALSE)
	return (EINVAL);
	break;
	}
	default:
	break;
	}

	return (0);
	}

	/*
	* This function takes a pointer to what should be a nvpair and it's size
	* and then verifies that all the nvpair fields make sense and can be
	* trusted. This function is used when decoding packed nvpairs.
	*/
	static int
	i_validate_nvpair(nvpair_t *nvp)
	{
	data_type_t type = NVP_TYPE(nvp);
	int size1, size2;

	/* verify nvp_name_sz, check the name string length */
	if (i_validate_nvpair_name(nvp) != 0)
	return (EFAULT);

	if (i_validate_nvpair_value(type, NVP_NELEM(nvp), NVP_VALUE(nvp)) != 0)
	return (EFAULT);

	/*
	* verify nvp_type, nvp_value_elem, and also possibly
	* verify string values and get the value size.
	*/
	size2 = i_get_value_size(type, NVP_VALUE(nvp), NVP_NELEM(nvp));
	size1 = nvp->nvp_size - NVP_VALOFF(nvp);
	if (size2 < 0 \|\| size1 != NV_ALIGN(size2))
	return (EFAULT);

	return (0);
	}

	static int
	nvlist_copy_pairs(nvlist_t snvl, nvlist_t dnvl)
	{
	nvpriv_t *priv;
	i_nvp_t *curr;

	if ((priv = (nvpriv_t *)(uintptr_t)snvl->nvl_priv) == NULL)
	return (EINVAL);

	for (curr = priv->nvp_list; curr != NULL; curr = curr->nvi_next) {
	nvpair_t *nvp = &curr->nvi_nvp;
	int err;

	if ((err = nvlist_add_common(dnvl, NVP_NAME(nvp), NVP_TYPE(nvp),
	NVP_NELEM(nvp), NVP_VALUE(nvp))) != 0)
	return (err);
	}

	return (0);
	}

	/*
	* Frees all memory allocated for an nvpair (like embedded lists) with
	* the exception of the nvpair buffer itself.
	*/
	static void
	nvpair_free(nvpair_t *nvp)
	{
	switch (NVP_TYPE(nvp)) {
	case DATA_TYPE_NVLIST:
	nvlist_free(EMBEDDED_NVL(nvp));
	break;
	case DATA_TYPE_NVLIST_ARRAY: {
	nvlist_t **nvlp = EMBEDDED_NVL_ARRAY(nvp);
	int i;

	for (i = 0; i < NVP_NELEM(nvp); i++)
	if (nvlp[i] != NULL)
	nvlist_free(nvlp[i]);
	break;
	}
	default:
	break;
	}
	}

	/*
	* nvlist_free - free an unpacked nvlist
	*/
	void
	nvlist_free(nvlist_t *nvl)
	{
	nvpriv_t *priv;
	i_nvp_t *curr;

	if (nvl == NULL \|\|
	(priv = (nvpriv_t *)(uintptr_t)nvl->nvl_priv) == NULL)
	return;

	/*
	* Unpacked nvlist are linked through i_nvp_t
	*/
	curr = priv->nvp_list;
	while (curr != NULL) {
	nvpair_t *nvp = &curr->nvi_nvp;
	curr = curr->nvi_next;

	nvpair_free(nvp);
	nvp_buf_free(nvl, nvp);
	}

	if (!(priv->nvp_stat & NV_STAT_EMBEDDED))
	nv_mem_free(priv, nvl, NV_ALIGN(sizeof (nvlist_t)));
	else
	nvl->nvl_priv = 0;

	nvt_tab_free(priv);
	nv_mem_free(priv, priv, sizeof (nvpriv_t));
	}

	static int
	nvlist_contains_nvp(nvlist_t nvl, nvpair_t nvp)
	{
	nvpriv_t priv = (nvpriv_t )(uintptr_t)nvl->nvl_priv;
	i_nvp_t *curr;

	if (nvp == NULL)
	return (0);

	for (curr = priv->nvp_list; curr != NULL; curr = curr->nvi_next)
	if (&curr->nvi_nvp == nvp)
	return (1);

	return (0);
	}

	/*
	* Make a copy of nvlist
	*/
	int
	nvlist_dup(nvlist_t nvl, nvlist_t *nvlp, int kmflag)
	{
	return (nvlist_xdup(nvl, nvlp, nvlist_nv_alloc(kmflag)));
	}

	int
	nvlist_xdup(nvlist_t nvl, nvlist_t nvlp, nv_alloc_t nva)
	{
	int err;
	nvlist_t *ret;

	if (nvl == NULL \|\| nvlp == NULL)
	return (EINVAL);

	if ((err = nvlist_xalloc(&ret, nvl->nvl_nvflag, nva)) != 0)
	return (err);

	if ((err = nvlist_copy_pairs(nvl, ret)) != 0)
	nvlist_free(ret);
	else
	*nvlp = ret;

	return (err);
	}

	/*
	* Remove all with matching name
	*/
	int
	nvlist_remove_all(nvlist_t nvl, const char name)
	{
	int error = ENOENT;

	if (nvl == NULL \|\| name == NULL \|\| nvl->nvl_priv == 0)
	return (EINVAL);

	nvpair_t *nvp;
	while ((nvp = nvt_lookup_name(nvl, name)) != NULL) {
	VERIFY0(nvlist_remove_nvpair(nvl, nvp));
	error = 0;
	}

	return (error);
	}

	/*
	* Remove first one with matching name and type
	*/
	int
	nvlist_remove(nvlist_t nvl, const char name, data_type_t type)
	{
	if (nvl == NULL \|\| name == NULL \|\| nvl->nvl_priv == 0)
	return (EINVAL);

	nvpair_t *nvp = nvt_lookup_name_type(nvl, name, type);
	if (nvp == NULL)
	return (ENOENT);

	return (nvlist_remove_nvpair(nvl, nvp));
	}

	int
	nvlist_remove_nvpair(nvlist_t nvl, nvpair_t nvp)
	{
	if (nvl == NULL \|\| nvp == NULL)
	return (EINVAL);

	int err = nvt_remove_nvpair(nvl, nvp);
	if (err != 0)
	return (err);

	nvp_buf_unlink(nvl, nvp);
	nvpair_free(nvp);
	nvp_buf_free(nvl, nvp);
	return (0);
	}

	/*
	* This function calculates the size of an nvpair value.
	*
	* The data argument controls the behavior in case of the data types
	* DATA_TYPE_STRING and
	* DATA_TYPE_STRING_ARRAY
	* Is data == NULL then the size of the string(s) is excluded.
	*/
	static int
	i_get_value_size(data_type_t type, const void *data, uint_t nelem)
	{
	uint64_t value_sz;

	if (i_validate_type_nelem(type, nelem) != 0)
	return (-1);

	/* Calculate required size for holding value */
	switch (type) {
	case DATA_TYPE_BOOLEAN:
	value_sz = 0;
	break;
	case DATA_TYPE_BOOLEAN_VALUE:
	value_sz = sizeof (boolean_t);
	break;
	case DATA_TYPE_BYTE:
	value_sz = sizeof (uchar_t);
	break;
	case DATA_TYPE_INT8:
	value_sz = sizeof (int8_t);
	break;
	case DATA_TYPE_UINT8:
	value_sz = sizeof (uint8_t);
	break;
	case DATA_TYPE_INT16:
	value_sz = sizeof (int16_t);
	break;
	case DATA_TYPE_UINT16:
	value_sz = sizeof (uint16_t);
	break;
	case DATA_TYPE_INT32:
	value_sz = sizeof (int32_t);
	break;
	case DATA_TYPE_UINT32:
	value_sz = sizeof (uint32_t);
	break;
	case DATA_TYPE_INT64:
	value_sz = sizeof (int64_t);
	break;
	case DATA_TYPE_UINT64:
	value_sz = sizeof (uint64_t);
	break;
	#if !defined(_KERNEL)
	case DATA_TYPE_DOUBLE:
	value_sz = sizeof (double);
	break;
	#endif
	case DATA_TYPE_STRING:
	if (data == NULL)
	value_sz = 0;
	else
	value_sz = strlen(data) + 1;
	break;
	case DATA_TYPE_BOOLEAN_ARRAY:
	value_sz = (uint64_t)nelem * sizeof (boolean_t);
	break;
	case DATA_TYPE_BYTE_ARRAY:
	value_sz = (uint64_t)nelem * sizeof (uchar_t);
	break;
	case DATA_TYPE_INT8_ARRAY:
	value_sz = (uint64_t)nelem * sizeof (int8_t);
	break;
	case DATA_TYPE_UINT8_ARRAY:
	value_sz = (uint64_t)nelem * sizeof (uint8_t);
	break;
	case DATA_TYPE_INT16_ARRAY:
	value_sz = (uint64_t)nelem * sizeof (int16_t);
	break;
	case DATA_TYPE_UINT16_ARRAY:
	value_sz = (uint64_t)nelem * sizeof (uint16_t);
	break;
	case DATA_TYPE_INT32_ARRAY:
	value_sz = (uint64_t)nelem * sizeof (int32_t);
	break;
	case DATA_TYPE_UINT32_ARRAY:
	value_sz = (uint64_t)nelem * sizeof (uint32_t);
	break;
	case DATA_TYPE_INT64_ARRAY:
	value_sz = (uint64_t)nelem * sizeof (int64_t);
	break;
	case DATA_TYPE_UINT64_ARRAY:
	value_sz = (uint64_t)nelem * sizeof (uint64_t);
	break;
	case DATA_TYPE_STRING_ARRAY:
	value_sz = (uint64_t)nelem * sizeof (uint64_t);

	if (data != NULL) {
	char const strs = data;
	uint_t i;

	/* no alignment requirement for strings */
	for (i = 0; i < nelem; i++) {
	if (strs[i] == NULL)
	return (-1);
	value_sz += strlen(strs[i]) + 1;
	}
	}
	break;
	case DATA_TYPE_HRTIME:
	value_sz = sizeof (hrtime_t);
	break;
	case DATA_TYPE_NVLIST:
	value_sz = NV_ALIGN(sizeof (nvlist_t));
	break;
	case DATA_TYPE_NVLIST_ARRAY:
	value_sz = (uint64_t)nelem * sizeof (uint64_t) +
	(uint64_t)nelem * NV_ALIGN(sizeof (nvlist_t));
	break;
	default:
	return (-1);
	}

	return (value_sz > INT32_MAX ? -1 : (int)value_sz);
	}

	static int
	nvlist_copy_embedded(nvlist_t nvl, nvlist_t onvl, nvlist_t *emb_nvl)
	{
	nvpriv_t *priv;
	int err;

	if ((priv = nv_priv_alloc_embedded((nvpriv_t *)(uintptr_t)
	nvl->nvl_priv)) == NULL)
	return (ENOMEM);

	nvlist_init(emb_nvl, onvl->nvl_nvflag, priv);

	if ((err = nvlist_copy_pairs(onvl, emb_nvl)) != 0) {
	nvlist_free(emb_nvl);
	emb_nvl->nvl_priv = 0;
	}

	return (err);
	}

	/*
	* nvlist_add_common - Add new <name,value> pair to nvlist
	*/
	static int
	nvlist_add_common(nvlist_t nvl, const char name,
	data_type_t type, uint_t nelem, const void *data)
	{
	nvpair_t *nvp;
	uint_t i;

	int nvp_sz, name_sz, value_sz;
	int err = 0;

	if (name == NULL \|\| nvl == NULL \|\| nvl->nvl_priv == 0)
	return (EINVAL);

	if (nelem != 0 && data == NULL)
	return (EINVAL);

	/*
	* Verify type and nelem and get the value size.
	* In case of data types DATA_TYPE_STRING and DATA_TYPE_STRING_ARRAY
	* is the size of the string(s) included.
	*/
	if ((value_sz = i_get_value_size(type, data, nelem)) < 0)
	return (EINVAL);

	if (i_validate_nvpair_value(type, nelem, data) != 0)
	return (EINVAL);

	/*
	* If we're adding an nvlist or nvlist array, ensure that we are not
	* adding the input nvlist to itself, which would cause recursion,
	* and ensure that no NULL nvlist pointers are present.
	*/
	switch (type) {
	case DATA_TYPE_NVLIST:
	if (data == nvl \|\| data == NULL)
	return (EINVAL);
	break;
	case DATA_TYPE_NVLIST_ARRAY: {
	nvlist_t onvlp = (nvlist_t )data;
	for (i = 0; i < nelem; i++) {
	if (onvlp[i] == nvl \|\| onvlp[i] == NULL)
	return (EINVAL);
	}
	break;
	}
	default:
	break;
	}

	/* calculate sizes of the nvpair elements and the nvpair itself */
	name_sz = strlen(name) + 1;
	if (name_sz >= 1ULL << (sizeof (nvp->nvp_name_sz) * NBBY - 1))
	return (EINVAL);

	nvp_sz = NVP_SIZE_CALC(name_sz, value_sz);

	if ((nvp = nvp_buf_alloc(nvl, nvp_sz)) == NULL)
	return (ENOMEM);

	ASSERT(nvp->nvp_size == nvp_sz);
	nvp->nvp_name_sz = name_sz;
	nvp->nvp_value_elem = nelem;
	nvp->nvp_type = type;
	bcopy(name, NVP_NAME(nvp), name_sz);

	switch (type) {
	case DATA_TYPE_BOOLEAN:
	break;
	case DATA_TYPE_STRING_ARRAY: {
	char const strs = data;
	char *buf = NVP_VALUE(nvp);
	char *cstrs = (void )buf;

	/* skip pre-allocated space for pointer array */
	buf += nelem * sizeof (uint64_t);
	for (i = 0; i < nelem; i++) {
	int slen = strlen(strs[i]) + 1;
	bcopy(strs[i], buf, slen);
	cstrs[i] = buf;
	buf += slen;
	}
	break;
	}
	case DATA_TYPE_NVLIST: {
	nvlist_t *nnvl = EMBEDDED_NVL(nvp);
	nvlist_t onvl = (nvlist_t )data;

	if ((err = nvlist_copy_embedded(nvl, onvl, nnvl)) != 0) {
	nvp_buf_free(nvl, nvp);
	return (err);
	}
	break;
	}
	case DATA_TYPE_NVLIST_ARRAY: {
	nvlist_t onvlp = (nvlist_t )data;
	nvlist_t **nvlp = EMBEDDED_NVL_ARRAY(nvp);
	nvlist_t embedded = (nvlist_t )
	((uintptr_t)nvlp + nelem * sizeof (uint64_t));

	for (i = 0; i < nelem; i++) {
	if ((err = nvlist_copy_embedded(nvl,
	onvlp[i], embedded)) != 0) {
	/*
	* Free any successfully created lists
	*/
	nvpair_free(nvp);
	nvp_buf_free(nvl, nvp);
	return (err);
	}

	nvlp[i] = embedded++;
	}
	break;
	}
	default:
	bcopy(data, NVP_VALUE(nvp), value_sz);
	}

	/* if unique name, remove before add */
	if (nvl->nvl_nvflag & NV_UNIQUE_NAME)
	(void) nvlist_remove_all(nvl, name);
	else if (nvl->nvl_nvflag & NV_UNIQUE_NAME_TYPE)
	(void) nvlist_remove(nvl, name, type);

	err = nvt_add_nvpair(nvl, nvp);
	if (err != 0) {
	nvpair_free(nvp);
	nvp_buf_free(nvl, nvp);
	return (err);
	}
	nvp_buf_link(nvl, nvp);

	return (0);
	}

	int
	nvlist_add_boolean(nvlist_t nvl, const char name)
	{
	return (nvlist_add_common(nvl, name, DATA_TYPE_BOOLEAN, 0, NULL));
	}

	int
	nvlist_add_boolean_value(nvlist_t nvl, const char name, boolean_t val)
	{
	return (nvlist_add_common(nvl, name, DATA_TYPE_BOOLEAN_VALUE, 1, &val));
	}

	int
	nvlist_add_byte(nvlist_t nvl, const char name, uchar_t val)
	{
	return (nvlist_add_common(nvl, name, DATA_TYPE_BYTE, 1, &val));
	}

	int
	nvlist_add_int8(nvlist_t nvl, const char name, int8_t val)
	{
	return (nvlist_add_common(nvl, name, DATA_TYPE_INT8, 1, &val));
	}

	int
	nvlist_add_uint8(nvlist_t nvl, const char name, uint8_t val)
	{
	return (nvlist_add_common(nvl, name, DATA_TYPE_UINT8, 1, &val));
	}

	int
	nvlist_add_int16(nvlist_t nvl, const char name, int16_t val)
	{
	return (nvlist_add_common(nvl, name, DATA_TYPE_INT16, 1, &val));
	}

	int
	nvlist_add_uint16(nvlist_t nvl, const char name, uint16_t val)
	{
	return (nvlist_add_common(nvl, name, DATA_TYPE_UINT16, 1, &val));
	}

	int
	nvlist_add_int32(nvlist_t nvl, const char name, int32_t val)
	{
	return (nvlist_add_common(nvl, name, DATA_TYPE_INT32, 1, &val));
	}

	int
	nvlist_add_uint32(nvlist_t nvl, const char name, uint32_t val)
	{
	return (nvlist_add_common(nvl, name, DATA_TYPE_UINT32, 1, &val));
	}

	int
	nvlist_add_int64(nvlist_t nvl, const char name, int64_t val)
	{
	return (nvlist_add_common(nvl, name, DATA_TYPE_INT64, 1, &val));
	}

	int
	nvlist_add_uint64(nvlist_t nvl, const char name, uint64_t val)
	{
	return (nvlist_add_common(nvl, name, DATA_TYPE_UINT64, 1, &val));
	}

	#if !defined(_KERNEL)
	int
	nvlist_add_double(nvlist_t nvl, const char name, double val)
	{
	return (nvlist_add_common(nvl, name, DATA_TYPE_DOUBLE, 1, &val));
	}
	#endif

	int
	nvlist_add_string(nvlist_t nvl, const char name, const char *val)
	{
	return (nvlist_add_common(nvl, name, DATA_TYPE_STRING, 1, (void *)val));
	}

	int
	nvlist_add_boolean_array(nvlist_t nvl, const char name,
	boolean_t *a, uint_t n)
	{
	return (nvlist_add_common(nvl, name, DATA_TYPE_BOOLEAN_ARRAY, n, a));
	}

	int
	nvlist_add_byte_array(nvlist_t nvl, const char name, uchar_t *a, uint_t n)
	{
	return (nvlist_add_common(nvl, name, DATA_TYPE_BYTE_ARRAY, n, a));
	}

	int
	nvlist_add_int8_array(nvlist_t nvl, const char name, int8_t *a, uint_t n)
	{
	return (nvlist_add_common(nvl, name, DATA_TYPE_INT8_ARRAY, n, a));
	}

	int
	nvlist_add_uint8_array(nvlist_t nvl, const char name, uint8_t *a, uint_t n)
	{
	return (nvlist_add_common(nvl, name, DATA_TYPE_UINT8_ARRAY, n, a));
	}

	int
	nvlist_add_int16_array(nvlist_t nvl, const char name, int16_t *a, uint_t n)
	{
	return (nvlist_add_common(nvl, name, DATA_TYPE_INT16_ARRAY, n, a));
	}

	int
	nvlist_add_uint16_array(nvlist_t nvl, const char name, uint16_t *a, uint_t n)
	{
	return (nvlist_add_common(nvl, name, DATA_TYPE_UINT16_ARRAY, n, a));
	}

	int
	nvlist_add_int32_array(nvlist_t nvl, const char name, int32_t *a, uint_t n)
	{
	return (nvlist_add_common(nvl, name, DATA_TYPE_INT32_ARRAY, n, a));
	}

	int
	nvlist_add_uint32_array(nvlist_t nvl, const char name, uint32_t *a, uint_t n)
	{
	return (nvlist_add_common(nvl, name, DATA_TYPE_UINT32_ARRAY, n, a));
	}

	int
	nvlist_add_int64_array(nvlist_t nvl, const char name, int64_t *a, uint_t n)
	{
	return (nvlist_add_common(nvl, name, DATA_TYPE_INT64_ARRAY, n, a));
	}

	int
	nvlist_add_uint64_array(nvlist_t nvl, const char name, uint64_t *a, uint_t n)
	{
	return (nvlist_add_common(nvl, name, DATA_TYPE_UINT64_ARRAY, n, a));
	}

	int
	nvlist_add_string_array(nvlist_t nvl, const char name,
	char const a, uint_t n)
	{
	return (nvlist_add_common(nvl, name, DATA_TYPE_STRING_ARRAY, n, a));
	}

	int
	nvlist_add_hrtime(nvlist_t nvl, const char name, hrtime_t val)
	{
	return (nvlist_add_common(nvl, name, DATA_TYPE_HRTIME, 1, &val));
	}

	int
	nvlist_add_nvlist(nvlist_t nvl, const char name, nvlist_t *val)
	{
	return (nvlist_add_common(nvl, name, DATA_TYPE_NVLIST, 1, val));
	}

	int
	nvlist_add_nvlist_array(nvlist_t nvl, const char name, nvlist_t **a, uint_t n)
	{
	return (nvlist_add_common(nvl, name, DATA_TYPE_NVLIST_ARRAY, n, a));
	}

	/* reading name-value pairs */
	nvpair_t *
	nvlist_next_nvpair(nvlist_t nvl, nvpair_t nvp)
	{
	nvpriv_t *priv;
	i_nvp_t *curr;

	if (nvl == NULL \|\|
	(priv = (nvpriv_t *)(uintptr_t)nvl->nvl_priv) == NULL)
	return (NULL);

	curr = NVPAIR2I_NVP(nvp);

	/*
	* Ensure that nvp is a valid nvpair on this nvlist.
	* NB: nvp_curr is used only as a hint so that we don't always
	* have to walk the list to determine if nvp is still on the list.
	*/
	if (nvp == NULL)
	curr = priv->nvp_list;
	else if (priv->nvp_curr == curr \|\| nvlist_contains_nvp(nvl, nvp))
	curr = curr->nvi_next;
	else
	curr = NULL;

	priv->nvp_curr = curr;

	return (curr != NULL ? &curr->nvi_nvp : NULL);
	}

	nvpair_t *
	nvlist_prev_nvpair(nvlist_t nvl, nvpair_t nvp)
	{
	nvpriv_t *priv;
	i_nvp_t *curr;

	if (nvl == NULL \|\|
	(priv = (nvpriv_t *)(uintptr_t)nvl->nvl_priv) == NULL)
	return (NULL);

	curr = NVPAIR2I_NVP(nvp);

	if (nvp == NULL)
	curr = priv->nvp_last;
	else if (priv->nvp_curr == curr \|\| nvlist_contains_nvp(nvl, nvp))
	curr = curr->nvi_prev;
	else
	curr = NULL;

	priv->nvp_curr = curr;

	return (curr != NULL ? &curr->nvi_nvp : NULL);
	}

	boolean_t
	nvlist_empty(nvlist_t *nvl)
	{
	nvpriv_t *priv;

	if (nvl == NULL \|\|
	(priv = (nvpriv_t *)(uintptr_t)nvl->nvl_priv) == NULL)
	return (B_TRUE);

	return (priv->nvp_list == NULL);
	}

	char *
	nvpair_name(nvpair_t *nvp)
	{
	return (NVP_NAME(nvp));
	}

	data_type_t
	nvpair_type(nvpair_t *nvp)
	{
	return (NVP_TYPE(nvp));
	}

	int
	nvpair_type_is_array(nvpair_t *nvp)
	{
	data_type_t type = NVP_TYPE(nvp);

	if ((type == DATA_TYPE_BYTE_ARRAY) \|\|
	(type == DATA_TYPE_INT8_ARRAY) \|\|
	(type == DATA_TYPE_UINT8_ARRAY) \|\|
	(type == DATA_TYPE_INT16_ARRAY) \|\|
	(type == DATA_TYPE_UINT16_ARRAY) \|\|
	(type == DATA_TYPE_INT32_ARRAY) \|\|
	(type == DATA_TYPE_UINT32_ARRAY) \|\|
	(type == DATA_TYPE_INT64_ARRAY) \|\|
	(type == DATA_TYPE_UINT64_ARRAY) \|\|
	(type == DATA_TYPE_BOOLEAN_ARRAY) \|\|
	(type == DATA_TYPE_STRING_ARRAY) \|\|
	(type == DATA_TYPE_NVLIST_ARRAY))
	return (1);
	return (0);

	}

	static int
	nvpair_value_common(nvpair_t nvp, data_type_t type, uint_t nelem, void *data)
	{
	int value_sz;

	if (nvp == NULL \|\| nvpair_type(nvp) != type)
	return (EINVAL);

	/*
	* For non-array types, we copy the data.
	* For array types (including string), we set a pointer.
	*/
	switch (type) {
	case DATA_TYPE_BOOLEAN:
	if (nelem != NULL)
	*nelem = 0;
	break;

	case DATA_TYPE_BOOLEAN_VALUE:
	case DATA_TYPE_BYTE:
	case DATA_TYPE_INT8:
	case DATA_TYPE_UINT8:
	case DATA_TYPE_INT16:
	case DATA_TYPE_UINT16:
	case DATA_TYPE_INT32:
	case DATA_TYPE_UINT32:
	case DATA_TYPE_INT64:
	case DATA_TYPE_UINT64:
	case DATA_TYPE_HRTIME:
	#if !defined(_KERNEL)
	case DATA_TYPE_DOUBLE:
	#endif
	if (data == NULL)
	return (EINVAL);
	if ((value_sz = i_get_value_size(type, NULL, 1)) < 0)
	return (EINVAL);
	bcopy(NVP_VALUE(nvp), data, (size_t)value_sz);
	if (nelem != NULL)
	*nelem = 1;
	break;

	case DATA_TYPE_NVLIST:
	case DATA_TYPE_STRING:
	if (data == NULL)
	return (EINVAL);
	(void )data = (void )NVP_VALUE(nvp);
	if (nelem != NULL)
	*nelem = 1;
	break;

	case DATA_TYPE_BOOLEAN_ARRAY:
	case DATA_TYPE_BYTE_ARRAY:
	case DATA_TYPE_INT8_ARRAY:
	case DATA_TYPE_UINT8_ARRAY:
	case DATA_TYPE_INT16_ARRAY:
	case DATA_TYPE_UINT16_ARRAY:
	case DATA_TYPE_INT32_ARRAY:
	case DATA_TYPE_UINT32_ARRAY:
	case DATA_TYPE_INT64_ARRAY:
	case DATA_TYPE_UINT64_ARRAY:
	case DATA_TYPE_STRING_ARRAY:
	case DATA_TYPE_NVLIST_ARRAY:
	if (nelem == NULL \|\| data == NULL)
	return (EINVAL);
	if ((*nelem = NVP_NELEM(nvp)) != 0)
	(void )data = (void )NVP_VALUE(nvp);
	else
	(void *)data = NULL;
	break;

	default:
	return (ENOTSUP);
	}

	return (0);
	}

	static int
	nvlist_lookup_common(nvlist_t nvl, const char name, data_type_t type,
	uint_t nelem, void data)
	{
	if (name == NULL \|\| nvl == NULL \|\| nvl->nvl_priv == 0)
	return (EINVAL);

	if (!(nvl->nvl_nvflag & (NV_UNIQUE_NAME \| NV_UNIQUE_NAME_TYPE)))
	return (ENOTSUP);

	nvpair_t *nvp = nvt_lookup_name_type(nvl, name, type);
	if (nvp == NULL)
	return (ENOENT);

	return (nvpair_value_common(nvp, type, nelem, data));
	}

	int
	nvlist_lookup_boolean(nvlist_t nvl, const char name)
	{
	return (nvlist_lookup_common(nvl, name, DATA_TYPE_BOOLEAN, NULL, NULL));
	}

	int
	nvlist_lookup_boolean_value(nvlist_t nvl, const char name, boolean_t *val)
	{
	return (nvlist_lookup_common(nvl, name,
	DATA_TYPE_BOOLEAN_VALUE, NULL, val));
	}

	int
	nvlist_lookup_byte(nvlist_t nvl, const char name, uchar_t *val)
	{
	return (nvlist_lookup_common(nvl, name, DATA_TYPE_BYTE, NULL, val));
	}

	int
	nvlist_lookup_int8(nvlist_t nvl, const char name, int8_t *val)
	{
	return (nvlist_lookup_common(nvl, name, DATA_TYPE_INT8, NULL, val));
	}

	int
	nvlist_lookup_uint8(nvlist_t nvl, const char name, uint8_t *val)
	{
	return (nvlist_lookup_common(nvl, name, DATA_TYPE_UINT8, NULL, val));
	}

	int
	nvlist_lookup_int16(nvlist_t nvl, const char name, int16_t *val)
	{
	return (nvlist_lookup_common(nvl, name, DATA_TYPE_INT16, NULL, val));
	}

	int
	nvlist_lookup_uint16(nvlist_t nvl, const char name, uint16_t *val)
	{
	return (nvlist_lookup_common(nvl, name, DATA_TYPE_UINT16, NULL, val));
	}

	int
	nvlist_lookup_int32(nvlist_t nvl, const char name, int32_t *val)
	{
	return (nvlist_lookup_common(nvl, name, DATA_TYPE_INT32, NULL, val));
	}

	int
	nvlist_lookup_uint32(nvlist_t nvl, const char name, uint32_t *val)
	{
	return (nvlist_lookup_common(nvl, name, DATA_TYPE_UINT32, NULL, val));
	}

	int
	nvlist_lookup_int64(nvlist_t nvl, const char name, int64_t *val)
	{
	return (nvlist_lookup_common(nvl, name, DATA_TYPE_INT64, NULL, val));
	}

	int
	nvlist_lookup_uint64(nvlist_t nvl, const char name, uint64_t *val)
	{
	return (nvlist_lookup_common(nvl, name, DATA_TYPE_UINT64, NULL, val));
	}

	#if !defined(_KERNEL)
	int
	nvlist_lookup_double(nvlist_t nvl, const char name, double *val)
	{
	return (nvlist_lookup_common(nvl, name, DATA_TYPE_DOUBLE, NULL, val));
	}
	#endif

	int
	nvlist_lookup_string(nvlist_t nvl, const char name, char **val)
	{
	return (nvlist_lookup_common(nvl, name, DATA_TYPE_STRING, NULL, val));
	}

	int
	nvlist_lookup_nvlist(nvlist_t nvl, const char name, nvlist_t **val)
	{
	return (nvlist_lookup_common(nvl, name, DATA_TYPE_NVLIST, NULL, val));
	}

	int
	nvlist_lookup_boolean_array(nvlist_t nvl, const char name,
	boolean_t *a, uint_t n)
	{
	return (nvlist_lookup_common(nvl, name,
	DATA_TYPE_BOOLEAN_ARRAY, n, a));
	}

	int
	nvlist_lookup_byte_array(nvlist_t nvl, const char name,
	uchar_t *a, uint_t n)
	{
	return (nvlist_lookup_common(nvl, name, DATA_TYPE_BYTE_ARRAY, n, a));
	}

	int
	nvlist_lookup_int8_array(nvlist_t nvl, const char name, int8_t *a, uint_t n)
	{
	return (nvlist_lookup_common(nvl, name, DATA_TYPE_INT8_ARRAY, n, a));
	}

	int
	nvlist_lookup_uint8_array(nvlist_t nvl, const char name,
	uint8_t *a, uint_t n)
	{
	return (nvlist_lookup_common(nvl, name, DATA_TYPE_UINT8_ARRAY, n, a));
	}

	int
	nvlist_lookup_int16_array(nvlist_t nvl, const char name,
	int16_t *a, uint_t n)
	{
	return (nvlist_lookup_common(nvl, name, DATA_TYPE_INT16_ARRAY, n, a));
	}

	int
	nvlist_lookup_uint16_array(nvlist_t nvl, const char name,
	uint16_t *a, uint_t n)
	{
	return (nvlist_lookup_common(nvl, name, DATA_TYPE_UINT16_ARRAY, n, a));
	}

	int
	nvlist_lookup_int32_array(nvlist_t nvl, const char name,
	int32_t *a, uint_t n)
	{
	return (nvlist_lookup_common(nvl, name, DATA_TYPE_INT32_ARRAY, n, a));
	}

	int
	nvlist_lookup_uint32_array(nvlist_t nvl, const char name,
	uint32_t *a, uint_t n)
	{
	return (nvlist_lookup_common(nvl, name, DATA_TYPE_UINT32_ARRAY, n, a));
	}

	int
	nvlist_lookup_int64_array(nvlist_t nvl, const char name,
	int64_t *a, uint_t n)
	{
	return (nvlist_lookup_common(nvl, name, DATA_TYPE_INT64_ARRAY, n, a));
	}

	int
	nvlist_lookup_uint64_array(nvlist_t nvl, const char name,
	uint64_t *a, uint_t n)
	{
	return (nvlist_lookup_common(nvl, name, DATA_TYPE_UINT64_ARRAY, n, a));
	}

	int
	nvlist_lookup_string_array(nvlist_t nvl, const char name,
	char **a, uint_t n)
	{
	return (nvlist_lookup_common(nvl, name, DATA_TYPE_STRING_ARRAY, n, a));
	}

	int
	nvlist_lookup_nvlist_array(nvlist_t nvl, const char name,
	nvlist_t **a, uint_t n)
	{
	return (nvlist_lookup_common(nvl, name, DATA_TYPE_NVLIST_ARRAY, n, a));
	}

	int
	nvlist_lookup_hrtime(nvlist_t nvl, const char name, hrtime_t *val)
	{
	return (nvlist_lookup_common(nvl, name, DATA_TYPE_HRTIME, NULL, val));
	}

	int
	nvlist_lookup_pairs(nvlist_t *nvl, int flag, ...)
	{
	va_list ap;
	char *name;
	int noentok = (flag & NV_FLAG_NOENTOK ? 1 : 0);
	int ret = 0;

	va_start(ap, flag);
	while (ret == 0 && (name = va_arg(ap, char *)) != NULL) {
	data_type_t type;
	void *val;
	uint_t *nelem;

	switch (type = va_arg(ap, data_type_t)) {
	case DATA_TYPE_BOOLEAN:
	ret = nvlist_lookup_common(nvl, name, type, NULL, NULL);
	break;

	case DATA_TYPE_BOOLEAN_VALUE:
	case DATA_TYPE_BYTE:
	case DATA_TYPE_INT8:
	case DATA_TYPE_UINT8:
	case DATA_TYPE_INT16:
	case DATA_TYPE_UINT16:
	case DATA_TYPE_INT32:
	case DATA_TYPE_UINT32:
	case DATA_TYPE_INT64:
	case DATA_TYPE_UINT64:
	case DATA_TYPE_HRTIME:
	case DATA_TYPE_STRING:
	case DATA_TYPE_NVLIST:
	#if !defined(_KERNEL)
	case DATA_TYPE_DOUBLE:
	#endif
	val = va_arg(ap, void *);
	ret = nvlist_lookup_common(nvl, name, type, NULL, val);
	break;

	case DATA_TYPE_BYTE_ARRAY:
	case DATA_TYPE_BOOLEAN_ARRAY:
	case DATA_TYPE_INT8_ARRAY:
	case DATA_TYPE_UINT8_ARRAY:
	case DATA_TYPE_INT16_ARRAY:
	case DATA_TYPE_UINT16_ARRAY:
	case DATA_TYPE_INT32_ARRAY:
	case DATA_TYPE_UINT32_ARRAY:
	case DATA_TYPE_INT64_ARRAY:
	case DATA_TYPE_UINT64_ARRAY:
	case DATA_TYPE_STRING_ARRAY:
	case DATA_TYPE_NVLIST_ARRAY:
	val = va_arg(ap, void *);
	nelem = va_arg(ap, uint_t *);
	ret = nvlist_lookup_common(nvl, name, type, nelem, val);
	break;

	default:
	ret = EINVAL;
	}

	if (ret == ENOENT && noentok)
	ret = 0;
	}
	va_end(ap);

	return (ret);
	}

	/*
	* Find the 'name'ed nvpair in the nvlist 'nvl'. If 'name' found, the function
	* returns zero and a pointer to the matching nvpair is returned in '*ret'
	* (given 'ret' is non-NULL). If 'sep' is specified then 'name' will penitrate
	* multiple levels of embedded nvlists, with 'sep' as the separator. As an
	* example, if sep is '.', name might look like: "a" or "a.b" or "a.c[3]" or
	* "a.d[3].e[1]". This matches the C syntax for array embed (for convenience,
	* code also supports "a.d[3]e[1]" syntax).
	*
	* If 'ip' is non-NULL and the last name component is an array, return the
	* value of the "...[index]" array index in *ip. For an array reference that
	* is not indexed, *ip will be returned as -1. If there is a syntax error in
	* 'name', and 'ep' is non-NULL then *ep will be set to point to the location
	* inside the 'name' string where the syntax error was detected.
	*/
	static int
	nvlist_lookup_nvpair_ei_sep(nvlist_t nvl, const char name, const char sep,
	nvpair_t *ret, int ip, char **ep)
	{
	nvpair_t *nvp;
	const char *np;
	char *sepp = NULL;
	char idxp, idxep;
	nvlist_t **nva;
	long idx = 0;
	int n;

	if (ip)
	ip = -1; / not indexed */
	if (ep)
	*ep = NULL;

	if ((nvl == NULL) \|\| (name == NULL))
	return (EINVAL);

	sepp = NULL;
	idx = 0;
	/* step through components of name */
	for (np = name; np && *np; np = sepp) {
	/* ensure unique names */
	if (!(nvl->nvl_nvflag & NV_UNIQUE_NAME))
	return (ENOTSUP);

	/* skip white space */
	skip_whitespace(np);
	if (*np == 0)
	break;

	/* set 'sepp' to end of current component 'np' */
	if (sep)
	sepp = strchr(np, sep);
	else
	sepp = NULL;

	/* find start of next "[ index ]..." */
	idxp = strchr(np, '[');

	/* if sepp comes first, set idxp to NULL */
	if (sepp && idxp && (sepp < idxp))
	idxp = NULL;

	/*
	* At this point 'idxp' is set if there is an index
	* expected for the current component.
	*/
	if (idxp) {
	/* set 'n' to length of current 'np' name component */
	n = idxp++ - np;

	/* keep sepp up to date for ep use as we advance /
	skip_whitespace(idxp);
	sepp = idxp;

	/* determine the index value */
	#if defined(_KERNEL)
	if (ddi_strtol(idxp, &idxep, 0, &idx))
	goto fail;
	#else
	idx = strtol(idxp, &idxep, 0);
	#endif
	if (idxep == idxp)
	goto fail;

	/* keep sepp up to date for ep use as we advance /
	sepp = idxep;

	/* skip white space index value and check for ']' */
	skip_whitespace(sepp);
	if (*sepp++ != ']')
	goto fail;

	/* for embedded arrays, support C syntax: "a[1].b" */
	skip_whitespace(sepp);
	if (sep && (*sepp == sep))
	sepp++;
	} else if (sepp) {
	n = sepp++ - np;
	} else {
	n = strlen(np);
	}

	/* trim trailing whitespace by reducing length of 'np' */
	if (n == 0)
	goto fail;
	for (n--; (np[n] == ' ') \|\| (np[n] == '\t'); n--)
	;
	n++;

	/* skip whitespace, and set sepp to NULL if complete */
	if (sepp) {
	skip_whitespace(sepp);
	if (*sepp == 0)
	sepp = NULL;
	}

	/*
	* At this point:
	* o 'n' is the length of current 'np' component.
	* o 'idxp' is set if there was an index, and value 'idx'.
	* o 'sepp' is set to the beginning of the next component,
	* and set to NULL if we have no more components.
	*
	* Search for nvpair with matching component name.
	*/
	for (nvp = nvlist_next_nvpair(nvl, NULL); nvp != NULL;
	nvp = nvlist_next_nvpair(nvl, nvp)) {

	/* continue if no match on name */
	if (strncmp(np, nvpair_name(nvp), n) \|\|
	(strlen(nvpair_name(nvp)) != n))
	continue;

	/* if indexed, verify type is array oriented */
	if (idxp && !nvpair_type_is_array(nvp))
	goto fail;

	/*
	* Full match found, return nvp and idx if this
	* was the last component.
	*/
	if (sepp == NULL) {
	if (ret)
	*ret = nvp;
	if (ip && idxp)
	ip = (int)idx; / return index */
	return (0); /* found */
	}

	/*
	* More components: current match must be
	* of DATA_TYPE_NVLIST or DATA_TYPE_NVLIST_ARRAY
	* to support going deeper.
	*/
	if (nvpair_type(nvp) == DATA_TYPE_NVLIST) {
	nvl = EMBEDDED_NVL(nvp);
	break;
	} else if (nvpair_type(nvp) == DATA_TYPE_NVLIST_ARRAY) {
	(void) nvpair_value_nvlist_array(nvp,
	&nva, (uint_t *)&n);
	if ((n < 0) \|\| (idx >= n))
	goto fail;
	nvl = nva[idx];
	break;
	}

	/* type does not support more levels */
	goto fail;
	}
	if (nvp == NULL)
	goto fail; /* 'name' not found */

	/* search for match of next component in embedded 'nvl' list */
	}

	fail: if (ep && sepp)
	*ep = sepp;
	return (EINVAL);
	}

	/*
	* Return pointer to nvpair with specified 'name'.
	*/
	int
	nvlist_lookup_nvpair(nvlist_t nvl, const char name, nvpair_t **ret)
	{
	return (nvlist_lookup_nvpair_ei_sep(nvl, name, 0, ret, NULL, NULL));
	}

	/*
	* Determine if named nvpair exists in nvlist (use embedded separator of '.'
	* and return array index). See nvlist_lookup_nvpair_ei_sep for more detailed
	* description.
	*/
	int nvlist_lookup_nvpair_embedded_index(nvlist_t *nvl,
	const char name, nvpair_t ret, int ip, char **ep)
	{
	return (nvlist_lookup_nvpair_ei_sep(nvl, name, '.', ret, ip, ep));
	}

	boolean_t
	nvlist_exists(nvlist_t nvl, const char name)
	{
	nvpriv_t *priv;
	nvpair_t *nvp;
	i_nvp_t *curr;

	if (name == NULL \|\| nvl == NULL \|\|
	(priv = (nvpriv_t *)(uintptr_t)nvl->nvl_priv) == NULL)
	return (B_FALSE);

	for (curr = priv->nvp_list; curr != NULL; curr = curr->nvi_next) {
	nvp = &curr->nvi_nvp;

	if (strcmp(name, NVP_NAME(nvp)) == 0)
	return (B_TRUE);
	}

	return (B_FALSE);
	}

	int
	nvpair_value_boolean_value(nvpair_t nvp, boolean_t val)
	{
	return (nvpair_value_common(nvp, DATA_TYPE_BOOLEAN_VALUE, NULL, val));
	}

	int
	nvpair_value_byte(nvpair_t nvp, uchar_t val)
	{
	return (nvpair_value_common(nvp, DATA_TYPE_BYTE, NULL, val));
	}

	int
	nvpair_value_int8(nvpair_t nvp, int8_t val)
	{
	return (nvpair_value_common(nvp, DATA_TYPE_INT8, NULL, val));
	}

	int
	nvpair_value_uint8(nvpair_t nvp, uint8_t val)
	{
	return (nvpair_value_common(nvp, DATA_TYPE_UINT8, NULL, val));
	}

	int
	nvpair_value_int16(nvpair_t nvp, int16_t val)
	{
	return (nvpair_value_common(nvp, DATA_TYPE_INT16, NULL, val));
	}

	int
	nvpair_value_uint16(nvpair_t nvp, uint16_t val)
	{
	return (nvpair_value_common(nvp, DATA_TYPE_UINT16, NULL, val));
	}

	int
	nvpair_value_int32(nvpair_t nvp, int32_t val)
	{
	return (nvpair_value_common(nvp, DATA_TYPE_INT32, NULL, val));
	}

	int
	nvpair_value_uint32(nvpair_t nvp, uint32_t val)
	{
	return (nvpair_value_common(nvp, DATA_TYPE_UINT32, NULL, val));
	}

	int
	nvpair_value_int64(nvpair_t nvp, int64_t val)
	{
	return (nvpair_value_common(nvp, DATA_TYPE_INT64, NULL, val));
	}

	int
	nvpair_value_uint64(nvpair_t nvp, uint64_t val)
	{
	return (nvpair_value_common(nvp, DATA_TYPE_UINT64, NULL, val));
	}

	#if !defined(_KERNEL)
	int
	nvpair_value_double(nvpair_t nvp, double val)
	{
	return (nvpair_value_common(nvp, DATA_TYPE_DOUBLE, NULL, val));
	}
	#endif

	int
	nvpair_value_string(nvpair_t nvp, char *val)
	{
	return (nvpair_value_common(nvp, DATA_TYPE_STRING, NULL, val));
	}

	int
	nvpair_value_nvlist(nvpair_t nvp, nvlist_t *val)
	{
	return (nvpair_value_common(nvp, DATA_TYPE_NVLIST, NULL, val));
	}

	int
	nvpair_value_boolean_array(nvpair_t nvp, boolean_t val, uint_t nelem)
	{
	return (nvpair_value_common(nvp, DATA_TYPE_BOOLEAN_ARRAY, nelem, val));
	}

	int
	nvpair_value_byte_array(nvpair_t nvp, uchar_t val, uint_t nelem)
	{
	return (nvpair_value_common(nvp, DATA_TYPE_BYTE_ARRAY, nelem, val));
	}

	int
	nvpair_value_int8_array(nvpair_t nvp, int8_t val, uint_t nelem)
	{
	return (nvpair_value_common(nvp, DATA_TYPE_INT8_ARRAY, nelem, val));
	}

	int
	nvpair_value_uint8_array(nvpair_t nvp, uint8_t val, uint_t nelem)
	{
	return (nvpair_value_common(nvp, DATA_TYPE_UINT8_ARRAY, nelem, val));
	}

	int
	nvpair_value_int16_array(nvpair_t nvp, int16_t val, uint_t nelem)
	{
	return (nvpair_value_common(nvp, DATA_TYPE_INT16_ARRAY, nelem, val));
	}

	int
	nvpair_value_uint16_array(nvpair_t nvp, uint16_t val, uint_t nelem)
	{
	return (nvpair_value_common(nvp, DATA_TYPE_UINT16_ARRAY, nelem, val));
	}

	int
	nvpair_value_int32_array(nvpair_t nvp, int32_t val, uint_t nelem)
	{
	return (nvpair_value_common(nvp, DATA_TYPE_INT32_ARRAY, nelem, val));
	}

	int
	nvpair_value_uint32_array(nvpair_t nvp, uint32_t val, uint_t nelem)
	{
	return (nvpair_value_common(nvp, DATA_TYPE_UINT32_ARRAY, nelem, val));
	}

	int
	nvpair_value_int64_array(nvpair_t nvp, int64_t val, uint_t nelem)
	{
	return (nvpair_value_common(nvp, DATA_TYPE_INT64_ARRAY, nelem, val));
	}

	int
	nvpair_value_uint64_array(nvpair_t nvp, uint64_t val, uint_t nelem)
	{
	return (nvpair_value_common(nvp, DATA_TYPE_UINT64_ARRAY, nelem, val));
	}

	int
	nvpair_value_string_array(nvpair_t nvp, char *val, uint_t nelem)
	{
	return (nvpair_value_common(nvp, DATA_TYPE_STRING_ARRAY, nelem, val));
	}

	int
	nvpair_value_nvlist_array(nvpair_t nvp, nvlist_t *val, uint_t nelem)
	{
	return (nvpair_value_common(nvp, DATA_TYPE_NVLIST_ARRAY, nelem, val));
	}

	int
	nvpair_value_hrtime(nvpair_t nvp, hrtime_t val)
	{
	return (nvpair_value_common(nvp, DATA_TYPE_HRTIME, NULL, val));
	}

	/*
	* Add specified pair to the list.
	*/
	int
	nvlist_add_nvpair(nvlist_t nvl, nvpair_t nvp)
	{
	if (nvl == NULL \|\| nvp == NULL)
	return (EINVAL);

	return (nvlist_add_common(nvl, NVP_NAME(nvp), NVP_TYPE(nvp),
	NVP_NELEM(nvp), NVP_VALUE(nvp)));
	}

	/*
	* Merge the supplied nvlists and put the result in dst.
	* The merged list will contain all names specified in both lists,
	* the values are taken from nvl in the case of duplicates.
	* Return 0 on success.
	*/
	/ARGSUSED/
	int
	nvlist_merge(nvlist_t dst, nvlist_t nvl, int flag)
	{
	if (nvl == NULL \|\| dst == NULL)
	return (EINVAL);

	if (dst != nvl)
	return (nvlist_copy_pairs(nvl, dst));

	return (0);
	}

	/*
	* Encoding related routines
	*/
	#define NVS_OP_ENCODE 0
	#define NVS_OP_DECODE 1
	#define NVS_OP_GETSIZE 2

	typedef struct nvs_ops nvs_ops_t;

	typedef struct {
	int nvs_op;
	const nvs_ops_t *nvs_ops;
	void *nvs_private;
	nvpriv_t *nvs_priv;
	int nvs_recursion;
	} nvstream_t;

	/*
	* nvs operations are:
	* - nvs_nvlist
	* encoding / decoding of an nvlist header (nvlist_t)
	* calculates the size used for header and end detection
	*
	* - nvs_nvpair
	* responsible for the first part of encoding / decoding of an nvpair
	* calculates the decoded size of an nvpair
	*
	* - nvs_nvp_op
	* second part of encoding / decoding of an nvpair
	*
	* - nvs_nvp_size
	* calculates the encoding size of an nvpair
	*
	* - nvs_nvl_fini
	* encodes the end detection mark (zeros).
	*/
	struct nvs_ops {
	int (nvs_nvlist)(nvstream_t , nvlist_t , size_t );
	int (nvs_nvpair)(nvstream_t , nvpair_t , size_t );
	int (nvs_nvp_op)(nvstream_t , nvpair_t *);
	int (nvs_nvp_size)(nvstream_t , nvpair_t , size_t );
	int (nvs_nvl_fini)(nvstream_t );
	};

	typedef struct {
	char nvh_encoding; /* nvs encoding method */
	char nvh_endian; /* nvs endian */
	char nvh_reserved1; /* reserved for future use */
	char nvh_reserved2; /* reserved for future use */
	} nvs_header_t;

	static int
	nvs_encode_pairs(nvstream_t nvs, nvlist_t nvl)
	{
	nvpriv_t priv = (nvpriv_t )(uintptr_t)nvl->nvl_priv;
	i_nvp_t *curr;

	/*
	* Walk nvpair in list and encode each nvpair
	*/
	for (curr = priv->nvp_list; curr != NULL; curr = curr->nvi_next)
	if (nvs->nvs_ops->nvs_nvpair(nvs, &curr->nvi_nvp, NULL) != 0)
	return (EFAULT);

	return (nvs->nvs_ops->nvs_nvl_fini(nvs));
	}

	static int
	nvs_decode_pairs(nvstream_t nvs, nvlist_t nvl)
	{
	nvpair_t *nvp;
	size_t nvsize;
	int err;

	/*
	* Get decoded size of next pair in stream, alloc
	* memory for nvpair_t, then decode the nvpair
	*/
	while ((err = nvs->nvs_ops->nvs_nvpair(nvs, NULL, &nvsize)) == 0) {
	if (nvsize == 0) /* end of list */
	break;

	/* make sure len makes sense */
	if (nvsize < NVP_SIZE_CALC(1, 0))
	return (EFAULT);

	if ((nvp = nvp_buf_alloc(nvl, nvsize)) == NULL)
	return (ENOMEM);

	if ((err = nvs->nvs_ops->nvs_nvp_op(nvs, nvp)) != 0) {
	nvp_buf_free(nvl, nvp);
	return (err);
	}

	if (i_validate_nvpair(nvp) != 0) {
	nvpair_free(nvp);
	nvp_buf_free(nvl, nvp);
	return (EFAULT);
	}

	err = nvt_add_nvpair(nvl, nvp);
	if (err != 0) {
	nvpair_free(nvp);
	nvp_buf_free(nvl, nvp);
	return (err);
	}
	nvp_buf_link(nvl, nvp);
	}
	return (err);
	}

	static int
	nvs_getsize_pairs(nvstream_t nvs, nvlist_t nvl, size_t *buflen)
	{
	nvpriv_t priv = (nvpriv_t )(uintptr_t)nvl->nvl_priv;
	i_nvp_t *curr;
	uint64_t nvsize = *buflen;
	size_t size;

	/*
	* Get encoded size of nvpairs in nvlist
	*/
	for (curr = priv->nvp_list; curr != NULL; curr = curr->nvi_next) {
	if (nvs->nvs_ops->nvs_nvp_size(nvs, &curr->nvi_nvp, &size) != 0)
	return (EINVAL);

	if ((nvsize += size) > INT32_MAX)
	return (EINVAL);
	}

	*buflen = nvsize;
	return (0);
	}

	static int
	nvs_operation(nvstream_t nvs, nvlist_t nvl, size_t *buflen)
	{
	int err;

	if (nvl->nvl_priv == 0)
	return (EFAULT);

	/*
	* Perform the operation, starting with header, then each nvpair
	*/
	if ((err = nvs->nvs_ops->nvs_nvlist(nvs, nvl, buflen)) != 0)
	return (err);

	switch (nvs->nvs_op) {
	case NVS_OP_ENCODE:
	err = nvs_encode_pairs(nvs, nvl);
	break;

	case NVS_OP_DECODE:
	err = nvs_decode_pairs(nvs, nvl);
	break;

	case NVS_OP_GETSIZE:
	err = nvs_getsize_pairs(nvs, nvl, buflen);
	break;

	default:
	err = EINVAL;
	}

	return (err);
	}

	static int
	nvs_embedded(nvstream_t nvs, nvlist_t embedded)
	{
	switch (nvs->nvs_op) {
	case NVS_OP_ENCODE: {
	int err;

	if (nvs->nvs_recursion >= nvpair_max_recursion)
	return (EINVAL);
	nvs->nvs_recursion++;
	err = nvs_operation(nvs, embedded, NULL);
	nvs->nvs_recursion--;
	return (err);
	}
	case NVS_OP_DECODE: {
	nvpriv_t *priv;
	int err;

	if (embedded->nvl_version != NV_VERSION)
	return (ENOTSUP);

	if ((priv = nv_priv_alloc_embedded(nvs->nvs_priv)) == NULL)
	return (ENOMEM);

	nvlist_init(embedded, embedded->nvl_nvflag, priv);

	if (nvs->nvs_recursion >= nvpair_max_recursion) {
	nvlist_free(embedded);
	return (EINVAL);
	}
	nvs->nvs_recursion++;
	if ((err = nvs_operation(nvs, embedded, NULL)) != 0)
	nvlist_free(embedded);
	nvs->nvs_recursion--;
	return (err);
	}
	default:
	break;
	}

	return (EINVAL);
	}

	static int
	nvs_embedded_nvl_array(nvstream_t nvs, nvpair_t nvp, size_t *size)
	{
	size_t nelem = NVP_NELEM(nvp);
	nvlist_t **nvlp = EMBEDDED_NVL_ARRAY(nvp);
	int i;

	switch (nvs->nvs_op) {
	case NVS_OP_ENCODE:
	for (i = 0; i < nelem; i++)
	if (nvs_embedded(nvs, nvlp[i]) != 0)
	return (EFAULT);
	break;

	case NVS_OP_DECODE: {
	size_t len = nelem * sizeof (uint64_t);
	nvlist_t embedded = (nvlist_t )((uintptr_t)nvlp + len);

	bzero(nvlp, len); /* don't trust packed data */
	for (i = 0; i < nelem; i++) {
	if (nvs_embedded(nvs, embedded) != 0) {
	nvpair_free(nvp);
	return (EFAULT);
	}

	nvlp[i] = embedded++;
	}
	break;
	}
	case NVS_OP_GETSIZE: {
	uint64_t nvsize = 0;

	for (i = 0; i < nelem; i++) {
	size_t nvp_sz = 0;

	if (nvs_operation(nvs, nvlp[i], &nvp_sz) != 0)
	return (EINVAL);

	if ((nvsize += nvp_sz) > INT32_MAX)
	return (EINVAL);
	}

	*size = nvsize;
	break;
	}
	default:
	return (EINVAL);
	}

	return (0);
	}

	static int nvs_native(nvstream_t , nvlist_t , char , size_t );
	static int nvs_xdr(nvstream_t , nvlist_t , char , size_t );

	/*
	* Common routine for nvlist operations:
	* encode, decode, getsize (encoded size).
	*/
	static int
	nvlist_common(nvlist_t nvl, char buf, size_t *buflen, int encoding,
	int nvs_op)
	{
	int err = 0;
	nvstream_t nvs;
	int nvl_endian;
	#if defined(_ZFS_LITTLE_ENDIAN)
	int host_endian = 1;
	#elif defined(_ZFS_BIG_ENDIAN)
	int host_endian = 0;
	#else
	#error "No endian defined!"
	#endif /* _ZFS_LITTLE_ENDIAN */
	nvs_header_t *nvh;

	if (buflen == NULL \|\| nvl == NULL \|\|
	(nvs.nvs_priv = (nvpriv_t *)(uintptr_t)nvl->nvl_priv) == NULL)
	return (EINVAL);

	nvs.nvs_op = nvs_op;
	nvs.nvs_recursion = 0;

	/*
	* For NVS_OP_ENCODE and NVS_OP_DECODE make sure an nvlist and
	* a buffer is allocated. The first 4 bytes in the buffer are
	* used for encoding method and host endian.
	*/
	switch (nvs_op) {
	case NVS_OP_ENCODE:
	if (buf == NULL \|\| *buflen < sizeof (nvs_header_t))
	return (EINVAL);

	nvh = (void *)buf;
	nvh->nvh_encoding = encoding;
	nvh->nvh_endian = nvl_endian = host_endian;
	nvh->nvh_reserved1 = 0;
	nvh->nvh_reserved2 = 0;
	break;

	case NVS_OP_DECODE:
	if (buf == NULL \|\| *buflen < sizeof (nvs_header_t))
	return (EINVAL);

	/* get method of encoding from first byte */
	nvh = (void *)buf;
	encoding = nvh->nvh_encoding;
	nvl_endian = nvh->nvh_endian;
	break;

	case NVS_OP_GETSIZE:
	nvl_endian = host_endian;

	/*
	* add the size for encoding
	*/
	*buflen = sizeof (nvs_header_t);
	break;

	default:
	return (ENOTSUP);
	}

	/*
	* Create an nvstream with proper encoding method
	*/
	switch (encoding) {
	case NV_ENCODE_NATIVE:
	/*
	* check endianness, in case we are unpacking
	* from a file
	*/
	if (nvl_endian != host_endian)
	return (ENOTSUP);
	err = nvs_native(&nvs, nvl, buf, buflen);
	break;
	case NV_ENCODE_XDR:
	err = nvs_xdr(&nvs, nvl, buf, buflen);
	break;
	default:
	err = ENOTSUP;
	break;
	}

	return (err);
	}

	int
	nvlist_size(nvlist_t nvl, size_t size, int encoding)
	{
	return (nvlist_common(nvl, NULL, size, encoding, NVS_OP_GETSIZE));
	}

	/*
	* Pack nvlist into contiguous memory
	*/
	int
	nvlist_pack(nvlist_t nvl, char bufp, size_t buflen, int encoding,
	int kmflag)
	{
	return (nvlist_xpack(nvl, bufp, buflen, encoding,
	nvlist_nv_alloc(kmflag)));
	}

	int
	nvlist_xpack(nvlist_t nvl, char bufp, size_t buflen, int encoding,
	nv_alloc_t *nva)
	{
	nvpriv_t nvpriv;
	size_t alloc_size;
	char *buf;
	int err;

	if (nva == NULL \|\| nvl == NULL \|\| bufp == NULL \|\| buflen == NULL)
	return (EINVAL);

	if (*bufp != NULL)
	return (nvlist_common(nvl, *bufp, buflen, encoding,
	NVS_OP_ENCODE));

	/*
	* Here is a difficult situation:
	* 1. The nvlist has fixed allocator properties.
	* All other nvlist routines (like nvlist_add_*, ...) use
	* these properties.
	* 2. When using nvlist_pack() the user can specify their own
	* allocator properties (e.g. by using KM_NOSLEEP).
	*
	* We use the user specified properties (2). A clearer solution
	* will be to remove the kmflag from nvlist_pack(), but we will
	* not change the interface.
	*/
	nv_priv_init(&nvpriv, nva, 0);

	if ((err = nvlist_size(nvl, &alloc_size, encoding)))
	return (err);

	if ((buf = nv_mem_zalloc(&nvpriv, alloc_size)) == NULL)
	return (ENOMEM);

	if ((err = nvlist_common(nvl, buf, &alloc_size, encoding,
	NVS_OP_ENCODE)) != 0) {
	nv_mem_free(&nvpriv, buf, alloc_size);
	} else {
	*buflen = alloc_size;
	*bufp = buf;
	}

	return (err);
	}

	/*
	* Unpack buf into an nvlist_t
	*/
	int
	nvlist_unpack(char buf, size_t buflen, nvlist_t *nvlp, int kmflag)
	{
	return (nvlist_xunpack(buf, buflen, nvlp, nvlist_nv_alloc(kmflag)));
	}

	int
	nvlist_xunpack(char buf, size_t buflen, nvlist_t nvlp, nv_alloc_t nva)
	{
	nvlist_t *nvl;
	int err;

	if (nvlp == NULL)
	return (EINVAL);

	if ((err = nvlist_xalloc(&nvl, 0, nva)) != 0)
	return (err);

	if ((err = nvlist_common(nvl, buf, &buflen, NV_ENCODE_NATIVE,
	NVS_OP_DECODE)) != 0)
	nvlist_free(nvl);
	else
	*nvlp = nvl;

	return (err);
	}

	/*
	* Native encoding functions
	*/
	typedef struct {
	/*
	* This structure is used when decoding a packed nvpair in
	* the native format. n_base points to a buffer containing the
	* packed nvpair. n_end is a pointer to the end of the buffer.
	* (n_end actually points to the first byte past the end of the
	* buffer.) n_curr is a pointer that lies between n_base and n_end.
	* It points to the current data that we are decoding.
	* The amount of data left in the buffer is equal to n_end - n_curr.
	* n_flag is used to recognize a packed embedded list.
	*/
	caddr_t n_base;
	caddr_t n_end;
	caddr_t n_curr;
	uint_t n_flag;
	} nvs_native_t;

	static int
	nvs_native_create(nvstream_t nvs, nvs_native_t native, char *buf,
	size_t buflen)
	{
	switch (nvs->nvs_op) {
	case NVS_OP_ENCODE:
	case NVS_OP_DECODE:
	nvs->nvs_private = native;
	native->n_curr = native->n_base = buf;
	native->n_end = buf + buflen;
	native->n_flag = 0;
	return (0);

	case NVS_OP_GETSIZE:
	nvs->nvs_private = native;
	native->n_curr = native->n_base = native->n_end = NULL;
	native->n_flag = 0;
	return (0);
	default:
	return (EINVAL);
	}
	}

	/ARGSUSED/
	static void
	nvs_native_destroy(nvstream_t *nvs)
	{
	}

	static int
	native_cp(nvstream_t nvs, void buf, size_t size)
	{
	nvs_native_t native = (nvs_native_t )nvs->nvs_private;

	if (native->n_curr + size > native->n_end)
	return (EFAULT);

	/*
	* The bcopy() below eliminates alignment requirement
	* on the buffer (stream) and is preferred over direct access.
	*/
	switch (nvs->nvs_op) {
	case NVS_OP_ENCODE:
	bcopy(buf, native->n_curr, size);
	break;
	case NVS_OP_DECODE:
	bcopy(native->n_curr, buf, size);
	break;
	default:
	return (EINVAL);
	}

	native->n_curr += size;
	return (0);
	}

	/*
	* operate on nvlist_t header
	*/
	static int
	nvs_native_nvlist(nvstream_t nvs, nvlist_t nvl, size_t *size)
	{
	nvs_native_t *native = nvs->nvs_private;

	switch (nvs->nvs_op) {
	case NVS_OP_ENCODE:
	case NVS_OP_DECODE:
	if (native->n_flag)
	return (0); /* packed embedded list */

	native->n_flag = 1;

	/* copy version and nvflag of the nvlist_t */
	if (native_cp(nvs, &nvl->nvl_version, sizeof (int32_t)) != 0 \|\|
	native_cp(nvs, &nvl->nvl_nvflag, sizeof (int32_t)) != 0)
	return (EFAULT);

	return (0);

	case NVS_OP_GETSIZE:
	/*
	* if calculate for packed embedded list
	* 4 for end of the embedded list
	* else
	* 2 * sizeof (int32_t) for nvl_version and nvl_nvflag
	* and 4 for end of the entire list
	*/
	if (native->n_flag) {
	*size += 4;
	} else {
	native->n_flag = 1;
	size += 2 sizeof (int32_t) + 4;
	}

	return (0);

	default:
	return (EINVAL);
	}
	}

	static int
	nvs_native_nvl_fini(nvstream_t *nvs)
	{
	if (nvs->nvs_op == NVS_OP_ENCODE) {
	nvs_native_t native = (nvs_native_t )nvs->nvs_private;
	/*
	* Add 4 zero bytes at end of nvlist. They are used
	* for end detection by the decode routine.
	*/
	if (native->n_curr + sizeof (int) > native->n_end)
	return (EFAULT);

	bzero(native->n_curr, sizeof (int));
	native->n_curr += sizeof (int);
	}

	return (0);
	}

	static int
	nvpair_native_embedded(nvstream_t nvs, nvpair_t nvp)
	{
	if (nvs->nvs_op == NVS_OP_ENCODE) {
	nvs_native_t native = (nvs_native_t )nvs->nvs_private;
	nvlist_t packed = (void )
	(native->n_curr - nvp->nvp_size + NVP_VALOFF(nvp));
	/*
	* Null out the pointer that is meaningless in the packed
	* structure. The address may not be aligned, so we have
	* to use bzero.
	*/
	bzero((char *)packed + offsetof(nvlist_t, nvl_priv),
	sizeof (uint64_t));
	}

	return (nvs_embedded(nvs, EMBEDDED_NVL(nvp)));
	}

	static int
	nvpair_native_embedded_array(nvstream_t nvs, nvpair_t nvp)
	{
	if (nvs->nvs_op == NVS_OP_ENCODE) {
	nvs_native_t native = (nvs_native_t )nvs->nvs_private;
	char *value = native->n_curr - nvp->nvp_size + NVP_VALOFF(nvp);
	size_t len = NVP_NELEM(nvp) * sizeof (uint64_t);
	nvlist_t packed = (nvlist_t )((uintptr_t)value + len);
	int i;
	/*
	* Null out pointers that are meaningless in the packed
	* structure. The addresses may not be aligned, so we have
	* to use bzero.
	*/
	bzero(value, len);

	for (i = 0; i < NVP_NELEM(nvp); i++, packed++)
	/*
	* Null out the pointer that is meaningless in the
	* packed structure. The address may not be aligned,
	* so we have to use bzero.
	*/
	bzero((char *)packed + offsetof(nvlist_t, nvl_priv),
	sizeof (uint64_t));
	}

	return (nvs_embedded_nvl_array(nvs, nvp, NULL));
	}

	static void
	nvpair_native_string_array(nvstream_t nvs, nvpair_t nvp)
	{
	switch (nvs->nvs_op) {
	case NVS_OP_ENCODE: {
	nvs_native_t native = (nvs_native_t )nvs->nvs_private;
	uint64_t strp = (void )
	(native->n_curr - nvp->nvp_size + NVP_VALOFF(nvp));
	/*
	* Null out pointers that are meaningless in the packed
	* structure. The addresses may not be aligned, so we have
	* to use bzero.
	*/
	bzero(strp, NVP_NELEM(nvp) * sizeof (uint64_t));
	break;
	}
	case NVS_OP_DECODE: {
	char *strp = (void )NVP_VALUE(nvp);
	char buf = ((char )strp + NVP_NELEM(nvp) * sizeof (uint64_t));
	int i;

	for (i = 0; i < NVP_NELEM(nvp); i++) {
	strp[i] = buf;
	buf += strlen(buf) + 1;
	}
	break;
	}
	}
	}

	static int
	nvs_native_nvp_op(nvstream_t nvs, nvpair_t nvp)
	{
	data_type_t type;
	int value_sz;
	int ret = 0;

	/*
	* We do the initial bcopy of the data before we look at
	* the nvpair type, because when we're decoding, we won't
	* have the correct values for the pair until we do the bcopy.
	*/
	switch (nvs->nvs_op) {
	case NVS_OP_ENCODE:
	case NVS_OP_DECODE:
	if (native_cp(nvs, nvp, nvp->nvp_size) != 0)
	return (EFAULT);
	break;
	default:
	return (EINVAL);
	}

	/* verify nvp_name_sz, check the name string length */
	if (i_validate_nvpair_name(nvp) != 0)
	return (EFAULT);

	type = NVP_TYPE(nvp);

	/*
	* Verify type and nelem and get the value size.
	* In case of data types DATA_TYPE_STRING and DATA_TYPE_STRING_ARRAY
	* is the size of the string(s) excluded.
	*/
	if ((value_sz = i_get_value_size(type, NULL, NVP_NELEM(nvp))) < 0)
	return (EFAULT);

	if (NVP_SIZE_CALC(nvp->nvp_name_sz, value_sz) > nvp->nvp_size)
	return (EFAULT);

	switch (type) {
	case DATA_TYPE_NVLIST:
	ret = nvpair_native_embedded(nvs, nvp);
	break;
	case DATA_TYPE_NVLIST_ARRAY:
	ret = nvpair_native_embedded_array(nvs, nvp);
	break;
	case DATA_TYPE_STRING_ARRAY:
	nvpair_native_string_array(nvs, nvp);
	break;
	default:
	break;
	}

	return (ret);
	}

	static int
	nvs_native_nvp_size(nvstream_t nvs, nvpair_t nvp, size_t *size)
	{
	uint64_t nvp_sz = nvp->nvp_size;

	switch (NVP_TYPE(nvp)) {
	case DATA_TYPE_NVLIST: {
	size_t nvsize = 0;

	if (nvs_operation(nvs, EMBEDDED_NVL(nvp), &nvsize) != 0)
	return (EINVAL);

	nvp_sz += nvsize;
	break;
	}
	case DATA_TYPE_NVLIST_ARRAY: {
	size_t nvsize;

	if (nvs_embedded_nvl_array(nvs, nvp, &nvsize) != 0)
	return (EINVAL);

	nvp_sz += nvsize;
	break;
	}
	default:
	break;
	}

	if (nvp_sz > INT32_MAX)
	return (EINVAL);

	*size = nvp_sz;

	return (0);
	}

	static int
	nvs_native_nvpair(nvstream_t nvs, nvpair_t nvp, size_t *size)
	{
	switch (nvs->nvs_op) {
	case NVS_OP_ENCODE:
	return (nvs_native_nvp_op(nvs, nvp));

	case NVS_OP_DECODE: {
	nvs_native_t native = (nvs_native_t )nvs->nvs_private;
	int32_t decode_len;

	/* try to read the size value from the stream */
	if (native->n_curr + sizeof (int32_t) > native->n_end)
	return (EFAULT);
	bcopy(native->n_curr, &decode_len, sizeof (int32_t));

	/* sanity check the size value */
	if (decode_len < 0 \|\|
	decode_len > native->n_end - native->n_curr)
	return (EFAULT);

	*size = decode_len;

	/*
	* If at the end of the stream then move the cursor
	* forward, otherwise nvpair_native_op() will read
	* the entire nvpair at the same cursor position.
	*/
	if (*size == 0)
	native->n_curr += sizeof (int32_t);
	break;
	}

	default:
	return (EINVAL);
	}

	return (0);
	}

	static const nvs_ops_t nvs_native_ops = {
	.nvs_nvlist = nvs_native_nvlist,
	.nvs_nvpair = nvs_native_nvpair,
	.nvs_nvp_op = nvs_native_nvp_op,
	.nvs_nvp_size = nvs_native_nvp_size,
	.nvs_nvl_fini = nvs_native_nvl_fini
	};

	static int
	nvs_native(nvstream_t nvs, nvlist_t nvl, char buf, size_t buflen)
	{
	nvs_native_t native;
	int err;

	nvs->nvs_ops = &nvs_native_ops;

	if ((err = nvs_native_create(nvs, &native, buf + sizeof (nvs_header_t),
	*buflen - sizeof (nvs_header_t))) != 0)
	return (err);

	err = nvs_operation(nvs, nvl, buflen);

	nvs_native_destroy(nvs);

	return (err);
	}

	/*
	* XDR encoding functions
	*
	* An xdr packed nvlist is encoded as:
	*
	* - encoding method and host endian (4 bytes)
	* - nvl_version (4 bytes)
	* - nvl_nvflag (4 bytes)
	*
	* - encoded nvpairs, the format of one xdr encoded nvpair is:
	* - encoded size of the nvpair (4 bytes)
	* - decoded size of the nvpair (4 bytes)
	* - name string, (4 + sizeof(NV_ALIGN4(string))
	* a string is coded as size (4 bytes) and data
	* - data type (4 bytes)
	* - number of elements in the nvpair (4 bytes)
	* - data
	*
	* - 2 zero's for end of the entire list (8 bytes)
	*/
	static int
	nvs_xdr_create(nvstream_t nvs, XDR xdr, char *buf, size_t buflen)
	{
	/* xdr data must be 4 byte aligned */
	if ((ulong_t)buf % 4 != 0)
	return (EFAULT);

	switch (nvs->nvs_op) {
	case NVS_OP_ENCODE:
	xdrmem_create(xdr, buf, (uint_t)buflen, XDR_ENCODE);
	nvs->nvs_private = xdr;
	return (0);
	case NVS_OP_DECODE:
	xdrmem_create(xdr, buf, (uint_t)buflen, XDR_DECODE);
	nvs->nvs_private = xdr;
	return (0);
	case NVS_OP_GETSIZE:
	nvs->nvs_private = NULL;
	return (0);
	default:
	return (EINVAL);
	}
	}

	static void
	nvs_xdr_destroy(nvstream_t *nvs)
	{
	switch (nvs->nvs_op) {
	case NVS_OP_ENCODE:
	case NVS_OP_DECODE:
	xdr_destroy((XDR *)nvs->nvs_private);
	break;
	default:
	break;
	}
	}

	static int
	nvs_xdr_nvlist(nvstream_t nvs, nvlist_t nvl, size_t *size)
	{
	switch (nvs->nvs_op) {
	case NVS_OP_ENCODE:
	case NVS_OP_DECODE: {
	XDR *xdr = nvs->nvs_private;

	if (!xdr_int(xdr, &nvl->nvl_version) \|\|
	!xdr_u_int(xdr, &nvl->nvl_nvflag))
	return (EFAULT);
	break;
	}
	case NVS_OP_GETSIZE: {
	/*
	* 2 * 4 for nvl_version + nvl_nvflag
	* and 8 for end of the entire list
	*/
	size += 2 4 + 8;
	break;
	}
	default:
	return (EINVAL);
	}
	return (0);
	}

	static int
	nvs_xdr_nvl_fini(nvstream_t *nvs)
	{
	if (nvs->nvs_op == NVS_OP_ENCODE) {
	XDR *xdr = nvs->nvs_private;
	int zero = 0;

	if (!xdr_int(xdr, &zero) \|\| !xdr_int(xdr, &zero))
	return (EFAULT);
	}

	return (0);
	}

	/*
	* xdrproc_t-compatible callbacks for xdr_array()
	*/

	#if defined(_KERNEL) && defined(__linux__) /* Linux kernel */

	#define NVS_BUILD_XDRPROC_T(type) \
	static bool_t \
	nvs_xdr_nvp_##type(XDR xdrs, void ptr) \
	{ \
	return (xdr_##type(xdrs, ptr)); \
	}

	#elif !defined(_KERNEL) && defined(XDR_CONTROL) /* tirpc */

	#define NVS_BUILD_XDRPROC_T(type) \
	static bool_t \
	nvs_xdr_nvp_##type(XDR *xdrs, ...) \
	{ \
	va_list args; \
	void *ptr; \
	\
	va_start(args, xdrs); \
	ptr = va_arg(args, void *); \
	va_end(args); \
	\
	return (xdr_##type(xdrs, ptr)); \
	}

	#else /* FreeBSD, sunrpc */

	#define NVS_BUILD_XDRPROC_T(type) \
	static bool_t \
	nvs_xdr_nvp_##type(XDR xdrs, void ptr, ...) \
	{ \
	return (xdr_##type(xdrs, ptr)); \
	}

	#endif

	/* BEGIN CSTYLED */
	NVS_BUILD_XDRPROC_T(char);
	NVS_BUILD_XDRPROC_T(short);
	NVS_BUILD_XDRPROC_T(u_short);
	NVS_BUILD_XDRPROC_T(int);
	NVS_BUILD_XDRPROC_T(u_int);
	NVS_BUILD_XDRPROC_T(longlong_t);
	NVS_BUILD_XDRPROC_T(u_longlong_t);
	/* END CSTYLED */

	/*
	* The format of xdr encoded nvpair is:
	* encode_size, decode_size, name string, data type, nelem, data
	*/
	static int
	nvs_xdr_nvp_op(nvstream_t nvs, nvpair_t nvp)
	{
	+ ASSERT(nvs != NULL && nvp != NULL);
	+
	data_type_t type;
	char *buf;
	char buf_end = (char )nvp + nvp->nvp_size;
	int value_sz;
	uint_t nelem, buflen;
	bool_t ret = FALSE;
	XDR *xdr = nvs->nvs_private;

	- ASSERT(xdr != NULL && nvp != NULL);
	+ ASSERT(xdr != NULL);

	/* name string */
	if ((buf = NVP_NAME(nvp)) >= buf_end)
	return (EFAULT);
	buflen = buf_end - buf;

	if (!xdr_string(xdr, &buf, buflen - 1))
	return (EFAULT);
	nvp->nvp_name_sz = strlen(buf) + 1;

	/* type and nelem */
	if (!xdr_int(xdr, (int *)&nvp->nvp_type) \|\|
	!xdr_int(xdr, &nvp->nvp_value_elem))
	return (EFAULT);

	type = NVP_TYPE(nvp);
	nelem = nvp->nvp_value_elem;

	/*
	* Verify type and nelem and get the value size.
	* In case of data types DATA_TYPE_STRING and DATA_TYPE_STRING_ARRAY
	* is the size of the string(s) excluded.
	*/
	if ((value_sz = i_get_value_size(type, NULL, nelem)) < 0)
	return (EFAULT);

	/* if there is no data to extract then return */
	if (nelem == 0)
	return (0);

	/* value */
	if ((buf = NVP_VALUE(nvp)) >= buf_end)
	return (EFAULT);
	buflen = buf_end - buf;

	if (buflen < value_sz)
	return (EFAULT);

	switch (type) {
	case DATA_TYPE_NVLIST:
	if (nvs_embedded(nvs, (void *)buf) == 0)
	return (0);
	break;

	case DATA_TYPE_NVLIST_ARRAY:
	if (nvs_embedded_nvl_array(nvs, nvp, NULL) == 0)
	return (0);
	break;

	case DATA_TYPE_BOOLEAN:
	ret = TRUE;
	break;

	case DATA_TYPE_BYTE:
	case DATA_TYPE_INT8:
	case DATA_TYPE_UINT8:
	ret = xdr_char(xdr, buf);
	break;

	case DATA_TYPE_INT16:
	ret = xdr_short(xdr, (void *)buf);
	break;

	case DATA_TYPE_UINT16:
	ret = xdr_u_short(xdr, (void *)buf);
	break;

	case DATA_TYPE_BOOLEAN_VALUE:
	case DATA_TYPE_INT32:
	ret = xdr_int(xdr, (void *)buf);
	break;

	case DATA_TYPE_UINT32:
	ret = xdr_u_int(xdr, (void *)buf);
	break;

	case DATA_TYPE_INT64:
	ret = xdr_longlong_t(xdr, (void *)buf);
	break;

	case DATA_TYPE_UINT64:
	ret = xdr_u_longlong_t(xdr, (void *)buf);
	break;

	case DATA_TYPE_HRTIME:
	/*
	* NOTE: must expose the definition of hrtime_t here
	*/
	ret = xdr_longlong_t(xdr, (void *)buf);
	break;
	#if !defined(_KERNEL)
	case DATA_TYPE_DOUBLE:
	ret = xdr_double(xdr, (void *)buf);
	break;
	#endif
	case DATA_TYPE_STRING:
	ret = xdr_string(xdr, &buf, buflen - 1);
	break;

	case DATA_TYPE_BYTE_ARRAY:
	ret = xdr_opaque(xdr, buf, nelem);
	break;

	case DATA_TYPE_INT8_ARRAY:
	case DATA_TYPE_UINT8_ARRAY:
	ret = xdr_array(xdr, &buf, &nelem, buflen, sizeof (int8_t),
	nvs_xdr_nvp_char);
	break;

	case DATA_TYPE_INT16_ARRAY:
	ret = xdr_array(xdr, &buf, &nelem, buflen / sizeof (int16_t),
	sizeof (int16_t), nvs_xdr_nvp_short);
	break;

	case DATA_TYPE_UINT16_ARRAY:
	ret = xdr_array(xdr, &buf, &nelem, buflen / sizeof (uint16_t),
	sizeof (uint16_t), nvs_xdr_nvp_u_short);
	break;

	case DATA_TYPE_BOOLEAN_ARRAY:
	case DATA_TYPE_INT32_ARRAY:
	ret = xdr_array(xdr, &buf, &nelem, buflen / sizeof (int32_t),
	sizeof (int32_t), nvs_xdr_nvp_int);
	break;

	case DATA_TYPE_UINT32_ARRAY:
	ret = xdr_array(xdr, &buf, &nelem, buflen / sizeof (uint32_t),
	sizeof (uint32_t), nvs_xdr_nvp_u_int);
	break;

	case DATA_TYPE_INT64_ARRAY:
	ret = xdr_array(xdr, &buf, &nelem, buflen / sizeof (int64_t),
	sizeof (int64_t), nvs_xdr_nvp_longlong_t);
	break;

	case DATA_TYPE_UINT64_ARRAY:
	ret = xdr_array(xdr, &buf, &nelem, buflen / sizeof (uint64_t),
	sizeof (uint64_t), nvs_xdr_nvp_u_longlong_t);
	break;

	case DATA_TYPE_STRING_ARRAY: {
	size_t len = nelem * sizeof (uint64_t);
	char *strp = (void )buf;
	int i;

	if (nvs->nvs_op == NVS_OP_DECODE)
	bzero(buf, len); /* don't trust packed data */

	for (i = 0; i < nelem; i++) {
	if (buflen <= len)
	return (EFAULT);

	buf += len;
	buflen -= len;

	if (xdr_string(xdr, &buf, buflen - 1) != TRUE)
	return (EFAULT);

	if (nvs->nvs_op == NVS_OP_DECODE)
	strp[i] = buf;
	len = strlen(buf) + 1;
	}
	ret = TRUE;
	break;
	}
	default:
	break;
	}

	return (ret == TRUE ? 0 : EFAULT);
	}

	static int
	nvs_xdr_nvp_size(nvstream_t nvs, nvpair_t nvp, size_t *size)
	{
	data_type_t type = NVP_TYPE(nvp);
	/*
	* encode_size + decode_size + name string size + data type + nelem
	* where name string size = 4 + NV_ALIGN4(strlen(NVP_NAME(nvp)))
	*/
	uint64_t nvp_sz = 4 + 4 + 4 + NV_ALIGN4(strlen(NVP_NAME(nvp))) + 4 + 4;

	switch (type) {
	case DATA_TYPE_BOOLEAN:
	break;

	case DATA_TYPE_BOOLEAN_VALUE:
	case DATA_TYPE_BYTE:
	case DATA_TYPE_INT8:
	case DATA_TYPE_UINT8:
	case DATA_TYPE_INT16:
	case DATA_TYPE_UINT16:
	case DATA_TYPE_INT32:
	case DATA_TYPE_UINT32:
	nvp_sz += 4; /* 4 is the minimum xdr unit */
	break;

	case DATA_TYPE_INT64:
	case DATA_TYPE_UINT64:
	case DATA_TYPE_HRTIME:
	#if !defined(_KERNEL)
	case DATA_TYPE_DOUBLE:
	#endif
	nvp_sz += 8;
	break;

	case DATA_TYPE_STRING:
	nvp_sz += 4 + NV_ALIGN4(strlen((char *)NVP_VALUE(nvp)));
	break;

	case DATA_TYPE_BYTE_ARRAY:
	nvp_sz += NV_ALIGN4(NVP_NELEM(nvp));
	break;

	case DATA_TYPE_BOOLEAN_ARRAY:
	case DATA_TYPE_INT8_ARRAY:
	case DATA_TYPE_UINT8_ARRAY:
	case DATA_TYPE_INT16_ARRAY:
	case DATA_TYPE_UINT16_ARRAY:
	case DATA_TYPE_INT32_ARRAY:
	case DATA_TYPE_UINT32_ARRAY:
	nvp_sz += 4 + 4 * (uint64_t)NVP_NELEM(nvp);
	break;

	case DATA_TYPE_INT64_ARRAY:
	case DATA_TYPE_UINT64_ARRAY:
	nvp_sz += 4 + 8 * (uint64_t)NVP_NELEM(nvp);
	break;

	case DATA_TYPE_STRING_ARRAY: {
	int i;
	char *strs = (void )NVP_VALUE(nvp);

	for (i = 0; i < NVP_NELEM(nvp); i++)
	nvp_sz += 4 + NV_ALIGN4(strlen(strs[i]));

	break;
	}

	case DATA_TYPE_NVLIST:
	case DATA_TYPE_NVLIST_ARRAY: {
	size_t nvsize = 0;
	int old_nvs_op = nvs->nvs_op;
	int err;

	nvs->nvs_op = NVS_OP_GETSIZE;
	if (type == DATA_TYPE_NVLIST)
	err = nvs_operation(nvs, EMBEDDED_NVL(nvp), &nvsize);
	else
	err = nvs_embedded_nvl_array(nvs, nvp, &nvsize);
	nvs->nvs_op = old_nvs_op;

	if (err != 0)
	return (EINVAL);

	nvp_sz += nvsize;
	break;
	}

	default:
	return (EINVAL);
	}

	if (nvp_sz > INT32_MAX)
	return (EINVAL);

	*size = nvp_sz;

	return (0);
	}


	/*
	* The NVS_XDR_MAX_LEN macro takes a packed xdr buffer of size x and estimates
	* the largest nvpair that could be encoded in the buffer.
	*
	* See comments above nvpair_xdr_op() for the format of xdr encoding.
	* The size of a xdr packed nvpair without any data is 5 words.
	*
	* Using the size of the data directly as an estimate would be ok
	* in all cases except one. If the data type is of DATA_TYPE_STRING_ARRAY
	* then the actual nvpair has space for an array of pointers to index
	* the strings. These pointers are not encoded into the packed xdr buffer.
	*
	* If the data is of type DATA_TYPE_STRING_ARRAY and all the strings are
	* of length 0, then each string is encoded in xdr format as a single word.
	* Therefore when expanded to an nvpair there will be 2.25 word used for
	* each string. (a int64_t allocated for pointer usage, and a single char
	* for the null termination.)
	*
	* This is the calculation performed by the NVS_XDR_MAX_LEN macro.
	*/
	#define NVS_XDR_HDR_LEN ((size_t)(5 * 4))
	#define NVS_XDR_DATA_LEN(y) (((size_t)(y) <= NVS_XDR_HDR_LEN) ? \
	0 : ((size_t)(y) - NVS_XDR_HDR_LEN))
	#define NVS_XDR_MAX_LEN(x) (NVP_SIZE_CALC(1, 0) + \
	(NVS_XDR_DATA_LEN(x) * 2) + \
	NV_ALIGN4((NVS_XDR_DATA_LEN(x) / 4)))

	static int
	nvs_xdr_nvpair(nvstream_t nvs, nvpair_t nvp, size_t *size)
	{
	XDR *xdr = nvs->nvs_private;
	int32_t encode_len, decode_len;

	switch (nvs->nvs_op) {
	case NVS_OP_ENCODE: {
	size_t nvsize;

	if (nvs_xdr_nvp_size(nvs, nvp, &nvsize) != 0)
	return (EFAULT);

	decode_len = nvp->nvp_size;
	encode_len = nvsize;
	if (!xdr_int(xdr, &encode_len) \|\| !xdr_int(xdr, &decode_len))
	return (EFAULT);

	return (nvs_xdr_nvp_op(nvs, nvp));
	}
	case NVS_OP_DECODE: {
	struct xdr_bytesrec bytesrec;

	/* get the encode and decode size */
	if (!xdr_int(xdr, &encode_len) \|\| !xdr_int(xdr, &decode_len))
	return (EFAULT);
	*size = decode_len;

	/* are we at the end of the stream? */
	if (*size == 0)
	return (0);

	/* sanity check the size parameter */
	if (!xdr_control(xdr, XDR_GET_BYTES_AVAIL, &bytesrec))
	return (EFAULT);

	if (*size > NVS_XDR_MAX_LEN(bytesrec.xc_num_avail))
	return (EFAULT);
	break;
	}

	default:
	return (EINVAL);
	}
	return (0);
	}

	static const struct nvs_ops nvs_xdr_ops = {
	.nvs_nvlist = nvs_xdr_nvlist,
	.nvs_nvpair = nvs_xdr_nvpair,
	.nvs_nvp_op = nvs_xdr_nvp_op,
	.nvs_nvp_size = nvs_xdr_nvp_size,
	.nvs_nvl_fini = nvs_xdr_nvl_fini
	};

	static int
	nvs_xdr(nvstream_t nvs, nvlist_t nvl, char buf, size_t buflen)
	{
	XDR xdr;
	int err;

	nvs->nvs_ops = &nvs_xdr_ops;

	if ((err = nvs_xdr_create(nvs, &xdr, buf + sizeof (nvs_header_t),
	*buflen - sizeof (nvs_header_t))) != 0)
	return (err);

	err = nvs_operation(nvs, nvl, buflen);

	nvs_xdr_destroy(nvs);

	return (err);
	}

	#if defined(_KERNEL)
	static int __init
	nvpair_init(void)
	{
	return (0);
	}

	static void __exit
	nvpair_fini(void)
	{
	}

	module_init(nvpair_init);
	module_exit(nvpair_fini);
	#endif

	ZFS_MODULE_DESCRIPTION("Generic name/value pair implementation");
	ZFS_MODULE_AUTHOR(ZFS_META_AUTHOR);
	ZFS_MODULE_LICENSE(ZFS_META_LICENSE);
	ZFS_MODULE_VERSION(ZFS_META_VERSION "-" ZFS_META_RELEASE);

	EXPORT_SYMBOL(nv_alloc_init);
	EXPORT_SYMBOL(nv_alloc_reset);
	EXPORT_SYMBOL(nv_alloc_fini);

	/* list management */
	EXPORT_SYMBOL(nvlist_alloc);
	EXPORT_SYMBOL(nvlist_free);
	EXPORT_SYMBOL(nvlist_size);
	EXPORT_SYMBOL(nvlist_pack);
	EXPORT_SYMBOL(nvlist_unpack);
	EXPORT_SYMBOL(nvlist_dup);
	EXPORT_SYMBOL(nvlist_merge);

	EXPORT_SYMBOL(nvlist_xalloc);
	EXPORT_SYMBOL(nvlist_xpack);
	EXPORT_SYMBOL(nvlist_xunpack);
	EXPORT_SYMBOL(nvlist_xdup);
	EXPORT_SYMBOL(nvlist_lookup_nv_alloc);

	EXPORT_SYMBOL(nvlist_add_nvpair);
	EXPORT_SYMBOL(nvlist_add_boolean);
	EXPORT_SYMBOL(nvlist_add_boolean_value);
	EXPORT_SYMBOL(nvlist_add_byte);
	EXPORT_SYMBOL(nvlist_add_int8);
	EXPORT_SYMBOL(nvlist_add_uint8);
	EXPORT_SYMBOL(nvlist_add_int16);
	EXPORT_SYMBOL(nvlist_add_uint16);
	EXPORT_SYMBOL(nvlist_add_int32);
	EXPORT_SYMBOL(nvlist_add_uint32);
	EXPORT_SYMBOL(nvlist_add_int64);
	EXPORT_SYMBOL(nvlist_add_uint64);
	EXPORT_SYMBOL(nvlist_add_string);
	EXPORT_SYMBOL(nvlist_add_nvlist);
	EXPORT_SYMBOL(nvlist_add_boolean_array);
	EXPORT_SYMBOL(nvlist_add_byte_array);
	EXPORT_SYMBOL(nvlist_add_int8_array);
	EXPORT_SYMBOL(nvlist_add_uint8_array);
	EXPORT_SYMBOL(nvlist_add_int16_array);
	EXPORT_SYMBOL(nvlist_add_uint16_array);
	EXPORT_SYMBOL(nvlist_add_int32_array);
	EXPORT_SYMBOL(nvlist_add_uint32_array);
	EXPORT_SYMBOL(nvlist_add_int64_array);
	EXPORT_SYMBOL(nvlist_add_uint64_array);
	EXPORT_SYMBOL(nvlist_add_string_array);
	EXPORT_SYMBOL(nvlist_add_nvlist_array);
	EXPORT_SYMBOL(nvlist_next_nvpair);
	EXPORT_SYMBOL(nvlist_prev_nvpair);
	EXPORT_SYMBOL(nvlist_empty);
	EXPORT_SYMBOL(nvlist_add_hrtime);

	EXPORT_SYMBOL(nvlist_remove);
	EXPORT_SYMBOL(nvlist_remove_nvpair);
	EXPORT_SYMBOL(nvlist_remove_all);

	EXPORT_SYMBOL(nvlist_lookup_boolean);
	EXPORT_SYMBOL(nvlist_lookup_boolean_value);
	EXPORT_SYMBOL(nvlist_lookup_byte);
	EXPORT_SYMBOL(nvlist_lookup_int8);
	EXPORT_SYMBOL(nvlist_lookup_uint8);
	EXPORT_SYMBOL(nvlist_lookup_int16);
	EXPORT_SYMBOL(nvlist_lookup_uint16);
	EXPORT_SYMBOL(nvlist_lookup_int32);
	EXPORT_SYMBOL(nvlist_lookup_uint32);
	EXPORT_SYMBOL(nvlist_lookup_int64);
	EXPORT_SYMBOL(nvlist_lookup_uint64);
	EXPORT_SYMBOL(nvlist_lookup_string);
	EXPORT_SYMBOL(nvlist_lookup_nvlist);
	EXPORT_SYMBOL(nvlist_lookup_boolean_array);
	EXPORT_SYMBOL(nvlist_lookup_byte_array);
	EXPORT_SYMBOL(nvlist_lookup_int8_array);
	EXPORT_SYMBOL(nvlist_lookup_uint8_array);
	EXPORT_SYMBOL(nvlist_lookup_int16_array);
	EXPORT_SYMBOL(nvlist_lookup_uint16_array);
	EXPORT_SYMBOL(nvlist_lookup_int32_array);
	EXPORT_SYMBOL(nvlist_lookup_uint32_array);
	EXPORT_SYMBOL(nvlist_lookup_int64_array);
	EXPORT_SYMBOL(nvlist_lookup_uint64_array);
	EXPORT_SYMBOL(nvlist_lookup_string_array);
	EXPORT_SYMBOL(nvlist_lookup_nvlist_array);
	EXPORT_SYMBOL(nvlist_lookup_hrtime);
	EXPORT_SYMBOL(nvlist_lookup_pairs);

	EXPORT_SYMBOL(nvlist_lookup_nvpair);
	EXPORT_SYMBOL(nvlist_exists);

	/* processing nvpair */
	EXPORT_SYMBOL(nvpair_name);
	EXPORT_SYMBOL(nvpair_type);
	EXPORT_SYMBOL(nvpair_value_boolean_value);
	EXPORT_SYMBOL(nvpair_value_byte);
	EXPORT_SYMBOL(nvpair_value_int8);
	EXPORT_SYMBOL(nvpair_value_uint8);
	EXPORT_SYMBOL(nvpair_value_int16);
	EXPORT_SYMBOL(nvpair_value_uint16);
	EXPORT_SYMBOL(nvpair_value_int32);
	EXPORT_SYMBOL(nvpair_value_uint32);
	EXPORT_SYMBOL(nvpair_value_int64);
	EXPORT_SYMBOL(nvpair_value_uint64);
	EXPORT_SYMBOL(nvpair_value_string);
	EXPORT_SYMBOL(nvpair_value_nvlist);
	EXPORT_SYMBOL(nvpair_value_boolean_array);
	EXPORT_SYMBOL(nvpair_value_byte_array);
	EXPORT_SYMBOL(nvpair_value_int8_array);
	EXPORT_SYMBOL(nvpair_value_uint8_array);
	EXPORT_SYMBOL(nvpair_value_int16_array);
	EXPORT_SYMBOL(nvpair_value_uint16_array);
	EXPORT_SYMBOL(nvpair_value_int32_array);
	EXPORT_SYMBOL(nvpair_value_uint32_array);
	EXPORT_SYMBOL(nvpair_value_int64_array);
	EXPORT_SYMBOL(nvpair_value_uint64_array);
	EXPORT_SYMBOL(nvpair_value_string_array);
	EXPORT_SYMBOL(nvpair_value_nvlist_array);
	EXPORT_SYMBOL(nvpair_value_hrtime);
	diff --git a/sys/contrib/openzfs/module/os/freebsd/zfs/vdev_geom.c b/sys/contrib/openzfs/module/os/freebsd/zfs/vdev_geom.c
	index 4ffa21495e74..2ef4811a8a4e 100644
	--- a/sys/contrib/openzfs/module/os/freebsd/zfs/vdev_geom.c
	+++ b/sys/contrib/openzfs/module/os/freebsd/zfs/vdev_geom.c
	@@ -1,1325 +1,1324 @@
	/*
	* 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) 2006 Pawel Jakub Dawidek <pjd@FreeBSD.org>
	* All rights reserved.
	*
	* Portions Copyright (c) 2012 Martin Matuska <mm@FreeBSD.org>
	*/

	#include <sys/zfs_context.h>
	#include <sys/param.h>
	#include <sys/kernel.h>
	#include <sys/bio.h>
	#include <sys/buf.h>
	#include <sys/file.h>
	#include <sys/spa.h>
	#include <sys/spa_impl.h>
	#include <sys/vdev_impl.h>
	#include <sys/vdev_os.h>
	#include <sys/fs/zfs.h>
	#include <sys/zio.h>
	#include <vm/vm_page.h>
	#include <geom/geom.h>
	#include <geom/geom_disk.h>
	#include <geom/geom_int.h>

	#ifndef g_topology_locked
	#define g_topology_locked() sx_xlocked(&topology_lock)
	#endif

	/*
	* Virtual device vector for GEOM.
	*/

	static g_attrchanged_t vdev_geom_attrchanged;
	struct g_class zfs_vdev_class = {
	.name = "ZFS::VDEV",
	.version = G_VERSION,
	.attrchanged = vdev_geom_attrchanged,
	};

	struct consumer_vdev_elem {
	SLIST_ENTRY(consumer_vdev_elem) elems;
	vdev_t *vd;
	};

	SLIST_HEAD(consumer_priv_t, consumer_vdev_elem);
	/* BEGIN CSTYLED */
	_Static_assert(sizeof (((struct g_consumer *)NULL)->private)
	== sizeof (struct consumer_priv_t*),
	"consumer_priv_t* can't be stored in g_consumer.private");

	DECLARE_GEOM_CLASS(zfs_vdev_class, zfs_vdev);

	SYSCTL_DECL(_vfs_zfs_vdev);
	/* Don't send BIO_FLUSH. */
	static int vdev_geom_bio_flush_disable;
	SYSCTL_INT(_vfs_zfs_vdev, OID_AUTO, bio_flush_disable, CTLFLAG_RWTUN,
	&vdev_geom_bio_flush_disable, 0, "Disable BIO_FLUSH");
	/* Don't send BIO_DELETE. */
	static int vdev_geom_bio_delete_disable;
	SYSCTL_INT(_vfs_zfs_vdev, OID_AUTO, bio_delete_disable, CTLFLAG_RWTUN,
	&vdev_geom_bio_delete_disable, 0, "Disable BIO_DELETE");
	/* END CSTYLED */

	/* Declare local functions */
	static void vdev_geom_detach(struct g_consumer *cp, boolean_t open_for_read);

	/*
	* Thread local storage used to indicate when a thread is probing geoms
	* for their guids. If NULL, this thread is not tasting geoms. If non NULL,
	* it is looking for a replacement for the vdev_t* that is its value.
	*/
	uint_t zfs_geom_probe_vdev_key;

	static void
	vdev_geom_set_physpath(vdev_t vd, struct g_consumer cp,
	boolean_t do_null_update)
	{
	boolean_t needs_update = B_FALSE;
	char *physpath;
	int error, physpath_len;

	physpath_len = MAXPATHLEN;
	physpath = g_malloc(physpath_len, M_WAITOK\|M_ZERO);
	error = g_io_getattr("GEOM::physpath", cp, &physpath_len, physpath);
	if (error == 0) {
	char *old_physpath;

	/* g_topology lock ensures that vdev has not been closed */
	g_topology_assert();
	old_physpath = vd->vdev_physpath;
	vd->vdev_physpath = spa_strdup(physpath);

	if (old_physpath != NULL) {
	needs_update = (strcmp(old_physpath,
	vd->vdev_physpath) != 0);
	spa_strfree(old_physpath);
	} else
	needs_update = do_null_update;
	}
	g_free(physpath);

	/*
	* If the physical path changed, update the config.
	* Only request an update for previously unset physpaths if
	* requested by the caller.
	*/
	if (needs_update)
	spa_async_request(vd->vdev_spa, SPA_ASYNC_CONFIG_UPDATE);

	}

	static void
	vdev_geom_attrchanged(struct g_consumer cp, const char attr)
	{
	struct consumer_priv_t *priv;
	struct consumer_vdev_elem *elem;

	priv = (struct consumer_priv_t *)&cp->private;
	if (SLIST_EMPTY(priv))
	return;

	SLIST_FOREACH(elem, priv, elems) {
	vdev_t *vd = elem->vd;
	if (strcmp(attr, "GEOM::physpath") == 0) {
	vdev_geom_set_physpath(vd, cp, /* null_update */B_TRUE);
	return;
	}
	}
	}

	static void
	vdev_geom_resize(struct g_consumer *cp)
	{
	struct consumer_priv_t *priv;
	struct consumer_vdev_elem *elem;
	spa_t *spa;
	vdev_t *vd;

	priv = (struct consumer_priv_t *)&cp->private;
	if (SLIST_EMPTY(priv))
	return;

	SLIST_FOREACH(elem, priv, elems) {
	vd = elem->vd;
	if (vd->vdev_state != VDEV_STATE_HEALTHY)
	continue;
	spa = vd->vdev_spa;
	if (!spa->spa_autoexpand)
	continue;
	vdev_online(spa, vd->vdev_guid, ZFS_ONLINE_EXPAND, NULL);
	}
	}

	static void
	vdev_geom_orphan(struct g_consumer *cp)
	{
	struct consumer_priv_t *priv;
	// cppcheck-suppress uninitvar
	struct consumer_vdev_elem *elem;

	g_topology_assert();

	priv = (struct consumer_priv_t *)&cp->private;
	if (SLIST_EMPTY(priv))
	/* Vdev close in progress. Ignore the event. */
	return;

	/*
	* Orphan callbacks occur from the GEOM event thread.
	* Concurrent with this call, new I/O requests may be
	* working their way through GEOM about to find out
	* (only once executed by the g_down thread) that we've
	* been orphaned from our disk provider. These I/Os
	* must be retired before we can detach our consumer.
	* This is most easily achieved by acquiring the
	* SPA ZIO configuration lock as a writer, but doing
	* so with the GEOM topology lock held would cause
	* a lock order reversal. Instead, rely on the SPA's
	* async removal support to invoke a close on this
	* vdev once it is safe to do so.
	*/
	- // cppcheck-suppress All
	SLIST_FOREACH(elem, priv, elems) {
	// cppcheck-suppress uninitvar
	vdev_t *vd = elem->vd;

	vd->vdev_remove_wanted = B_TRUE;
	spa_async_request(vd->vdev_spa, SPA_ASYNC_REMOVE);
	}
	}

	static struct g_consumer *
	vdev_geom_attach(struct g_provider pp, vdev_t vd, boolean_t sanity)
	{
	struct g_geom *gp;
	struct g_consumer *cp;
	int error;

	g_topology_assert();

	ZFS_LOG(1, "Attaching to %s.", pp->name);

	if (sanity) {
	if (pp->sectorsize > VDEV_PAD_SIZE \|\| !ISP2(pp->sectorsize)) {
	ZFS_LOG(1, "Failing attach of %s. "
	"Incompatible sectorsize %d\n",
	pp->name, pp->sectorsize);
	return (NULL);
	} else if (pp->mediasize < SPA_MINDEVSIZE) {
	ZFS_LOG(1, "Failing attach of %s. "
	"Incompatible mediasize %ju\n",
	pp->name, pp->mediasize);
	return (NULL);
	}
	}

	/* Do we have geom already? No? Create one. */
	LIST_FOREACH(gp, &zfs_vdev_class.geom, geom) {
	if (gp->flags & G_GEOM_WITHER)
	continue;
	if (strcmp(gp->name, "zfs::vdev") != 0)
	continue;
	break;
	}
	if (gp == NULL) {
	gp = g_new_geomf(&zfs_vdev_class, "zfs::vdev");
	gp->orphan = vdev_geom_orphan;
	gp->attrchanged = vdev_geom_attrchanged;
	gp->resize = vdev_geom_resize;
	cp = g_new_consumer(gp);
	error = g_attach(cp, pp);
	if (error != 0) {
	ZFS_LOG(1, "%s(%d): g_attach failed: %d\n", __func__,
	__LINE__, error);
	vdev_geom_detach(cp, B_FALSE);
	return (NULL);
	}
	error = g_access(cp, 1, 0, 1);
	if (error != 0) {
	ZFS_LOG(1, "%s(%d): g_access failed: %d\n", __func__,
	__LINE__, error);
	vdev_geom_detach(cp, B_FALSE);
	return (NULL);
	}
	ZFS_LOG(1, "Created geom and consumer for %s.", pp->name);
	} else {
	/* Check if we are already connected to this provider. */
	LIST_FOREACH(cp, &gp->consumer, consumer) {
	if (cp->provider == pp) {
	ZFS_LOG(1, "Found consumer for %s.", pp->name);
	break;
	}
	}
	if (cp == NULL) {
	cp = g_new_consumer(gp);
	error = g_attach(cp, pp);
	if (error != 0) {
	ZFS_LOG(1, "%s(%d): g_attach failed: %d\n",
	__func__, __LINE__, error);
	vdev_geom_detach(cp, B_FALSE);
	return (NULL);
	}
	error = g_access(cp, 1, 0, 1);
	if (error != 0) {
	ZFS_LOG(1, "%s(%d): g_access failed: %d\n",
	__func__, __LINE__, error);
	vdev_geom_detach(cp, B_FALSE);
	return (NULL);
	}
	ZFS_LOG(1, "Created consumer for %s.", pp->name);
	} else {
	error = g_access(cp, 1, 0, 1);
	if (error != 0) {
	ZFS_LOG(1, "%s(%d): g_access failed: %d\n",
	__func__, __LINE__, error);
	return (NULL);
	}
	ZFS_LOG(1, "Used existing consumer for %s.", pp->name);
	}
	}

	if (vd != NULL)
	vd->vdev_tsd = cp;

	cp->flags \|= G_CF_DIRECT_SEND \| G_CF_DIRECT_RECEIVE;
	return (cp);
	}

	static void
	vdev_geom_detach(struct g_consumer *cp, boolean_t open_for_read)
	{
	struct g_geom *gp;

	g_topology_assert();

	ZFS_LOG(1, "Detaching from %s.",
	cp->provider && cp->provider->name ? cp->provider->name : "NULL");

	gp = cp->geom;
	if (open_for_read)
	g_access(cp, -1, 0, -1);
	/* Destroy consumer on last close. */
	if (cp->acr == 0 && cp->ace == 0) {
	if (cp->acw > 0)
	g_access(cp, 0, -cp->acw, 0);
	if (cp->provider != NULL) {
	ZFS_LOG(1, "Destroying consumer for %s.",
	cp->provider->name ? cp->provider->name : "NULL");
	g_detach(cp);
	}
	g_destroy_consumer(cp);
	}
	/* Destroy geom if there are no consumers left. */
	if (LIST_EMPTY(&gp->consumer)) {
	ZFS_LOG(1, "Destroyed geom %s.", gp->name);
	g_wither_geom(gp, ENXIO);
	}
	}

	static void
	vdev_geom_close_locked(vdev_t *vd)
	{
	struct g_consumer *cp;
	struct consumer_priv_t *priv;
	struct consumer_vdev_elem elem, elem_temp;

	g_topology_assert();

	cp = vd->vdev_tsd;
	vd->vdev_delayed_close = B_FALSE;
	if (cp == NULL)
	return;

	ZFS_LOG(1, "Closing access to %s.", cp->provider->name);
	KASSERT(cp->private != NULL, ("%s: cp->private is NULL", __func__));
	priv = (struct consumer_priv_t *)&cp->private;
	vd->vdev_tsd = NULL;
	SLIST_FOREACH_SAFE(elem, priv, elems, elem_temp) {
	if (elem->vd == vd) {
	SLIST_REMOVE(priv, elem, consumer_vdev_elem, elems);
	g_free(elem);
	}
	}

	vdev_geom_detach(cp, B_TRUE);
	}

	/*
	* Issue one or more bios to the vdev in parallel
	* cmds, datas, offsets, errors, and sizes are arrays of length ncmds. Each IO
	* operation is described by parallel entries from each array. There may be
	* more bios actually issued than entries in the array
	*/
	static void
	vdev_geom_io(struct g_consumer cp, int cmds, void *datas, off_t offsets,
	off_t sizes, int errors, int ncmds)
	{
	struct bio **bios;
	uint8_t *p;
	off_t off, maxio, s, end;
	int i, n_bios, j;
	size_t bios_size;

	#if __FreeBSD_version > 1300130
	maxio = maxphys - (maxphys % cp->provider->sectorsize);
	#else
	maxio = MAXPHYS - (MAXPHYS % cp->provider->sectorsize);
	#endif
	n_bios = 0;

	/* How many bios are required for all commands ? */
	for (i = 0; i < ncmds; i++)
	n_bios += (sizes[i] + maxio - 1) / maxio;

	/* Allocate memory for the bios */
	bios_size = n_bios * sizeof (struct bio *);
	bios = kmem_zalloc(bios_size, KM_SLEEP);

	/* Prepare and issue all of the bios */
	for (i = j = 0; i < ncmds; i++) {
	off = offsets[i];
	p = datas[i];
	s = sizes[i];
	end = off + s;
	ASSERT0(off % cp->provider->sectorsize);
	ASSERT0(s % cp->provider->sectorsize);

	for (; off < end; off += maxio, p += maxio, s -= maxio, j++) {
	bios[j] = g_alloc_bio();
	bios[j]->bio_cmd = cmds[i];
	bios[j]->bio_done = NULL;
	bios[j]->bio_offset = off;
	bios[j]->bio_length = MIN(s, maxio);
	bios[j]->bio_data = (caddr_t)p;
	g_io_request(bios[j], cp);
	}
	}
	ASSERT3S(j, ==, n_bios);

	/* Wait for all of the bios to complete, and clean them up */
	for (i = j = 0; i < ncmds; i++) {
	off = offsets[i];
	s = sizes[i];
	end = off + s;

	for (; off < end; off += maxio, s -= maxio, j++) {
	errors[i] = biowait(bios[j], "vdev_geom_io") \|\|
	errors[i];
	g_destroy_bio(bios[j]);
	}
	}
	kmem_free(bios, bios_size);
	}

	/*
	* Read the vdev config from a device. Return the number of valid labels that
	* were found. The vdev config will be returned in config if and only if at
	* least one valid label was found.
	*/
	static int
	vdev_geom_read_config(struct g_consumer cp, nvlist_t *configp)
	{
	struct g_provider *pp;
	nvlist_t *config;
	vdev_phys_t *vdev_lists[VDEV_LABELS];
	char *buf;
	size_t buflen;
	uint64_t psize, state, txg;
	off_t offsets[VDEV_LABELS];
	off_t size;
	off_t sizes[VDEV_LABELS];
	int cmds[VDEV_LABELS];
	int errors[VDEV_LABELS];
	int l, nlabels;

	g_topology_assert_not();

	pp = cp->provider;
	ZFS_LOG(1, "Reading config from %s...", pp->name);

	psize = pp->mediasize;
	psize = P2ALIGN(psize, (uint64_t)sizeof (vdev_label_t));

	size = sizeof (*vdev_lists[0]) + pp->sectorsize -
	((sizeof (*vdev_lists[0]) - 1) % pp->sectorsize) - 1;

	buflen = sizeof (vdev_lists[0]->vp_nvlist);

	/* Create all of the IO requests */
	for (l = 0; l < VDEV_LABELS; l++) {
	cmds[l] = BIO_READ;
	vdev_lists[l] = kmem_alloc(size, KM_SLEEP);
	offsets[l] = vdev_label_offset(psize, l, 0) + VDEV_SKIP_SIZE;
	sizes[l] = size;
	errors[l] = 0;
	ASSERT0(offsets[l] % pp->sectorsize);
	}

	/* Issue the IO requests */
	vdev_geom_io(cp, cmds, (void**)vdev_lists, offsets, sizes, errors,
	VDEV_LABELS);

	/* Parse the labels */
	config = *configp = NULL;
	nlabels = 0;
	for (l = 0; l < VDEV_LABELS; l++) {
	if (errors[l] != 0)
	continue;

	buf = vdev_lists[l]->vp_nvlist;

	if (nvlist_unpack(buf, buflen, &config, 0) != 0)
	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 (*configp != NULL)
	nvlist_free(*configp);
	*configp = config;
	nlabels++;
	}

	/* Free the label storage */
	for (l = 0; l < VDEV_LABELS; l++)
	kmem_free(vdev_lists[l], size);

	return (nlabels);
	}

	static void
	resize_configs(nvlist_t **configs, uint64_t count, uint64_t id)
	{
	nvlist_t **new_configs;
	uint64_t i;

	if (id < *count)
	return;
	new_configs = kmem_zalloc((id + 1) * sizeof (nvlist_t *),
	KM_SLEEP);
	for (i = 0; i < *count; i++)
	new_configs[i] = (*configs)[i];
	if (*configs != NULL)
	kmem_free(configs, count * sizeof (void *));
	*configs = new_configs;
	*count = id + 1;
	}

	static void
	process_vdev_config(nvlist_t **configs, uint64_t count, nvlist_t *cfg,
	const char name, uint64_t known_pool_guid)
	{
	nvlist_t *vdev_tree;
	uint64_t pool_guid;
	uint64_t vdev_guid;
	uint64_t id, txg, known_txg;
	char *pname;

	if (nvlist_lookup_string(cfg, ZPOOL_CONFIG_POOL_NAME, &pname) != 0 \|\|
	strcmp(pname, name) != 0)
	goto ignore;

	if (nvlist_lookup_uint64(cfg, ZPOOL_CONFIG_POOL_GUID, &pool_guid) != 0)
	goto ignore;

	if (nvlist_lookup_uint64(cfg, ZPOOL_CONFIG_TOP_GUID, &vdev_guid) != 0)
	goto ignore;

	if (nvlist_lookup_nvlist(cfg, ZPOOL_CONFIG_VDEV_TREE, &vdev_tree) != 0)
	goto ignore;

	if (nvlist_lookup_uint64(vdev_tree, ZPOOL_CONFIG_ID, &id) != 0)
	goto ignore;

	txg = fnvlist_lookup_uint64(cfg, ZPOOL_CONFIG_POOL_TXG);

	if (*known_pool_guid != 0) {
	if (pool_guid != *known_pool_guid)
	goto ignore;
	} else
	*known_pool_guid = pool_guid;

	resize_configs(configs, count, id);

	if ((*configs)[id] != NULL) {
	known_txg = fnvlist_lookup_uint64((*configs)[id],
	ZPOOL_CONFIG_POOL_TXG);
	if (txg <= known_txg)
	goto ignore;
	nvlist_free((*configs)[id]);
	}

	(*configs)[id] = cfg;
	return;

	ignore:
	nvlist_free(cfg);
	}

	int
	vdev_geom_read_pool_label(const char *name,
	nvlist_t **configs, uint64_t count)
	{
	struct g_class *mp;
	struct g_geom *gp;
	struct g_provider *pp;
	struct g_consumer *zcp;
	nvlist_t *vdev_cfg;
	uint64_t pool_guid;
	int nlabels;

	DROP_GIANT();
	g_topology_lock();

	*configs = NULL;
	*count = 0;
	pool_guid = 0;
	LIST_FOREACH(mp, &g_classes, class) {
	if (mp == &zfs_vdev_class)
	continue;
	LIST_FOREACH(gp, &mp->geom, geom) {
	if (gp->flags & G_GEOM_WITHER)
	continue;
	LIST_FOREACH(pp, &gp->provider, provider) {
	if (pp->flags & G_PF_WITHER)
	continue;
	zcp = vdev_geom_attach(pp, NULL, B_TRUE);
	if (zcp == NULL)
	continue;
	g_topology_unlock();
	nlabels = vdev_geom_read_config(zcp, &vdev_cfg);
	g_topology_lock();
	vdev_geom_detach(zcp, B_TRUE);
	if (nlabels == 0)
	continue;
	ZFS_LOG(1, "successfully read vdev config");

	process_vdev_config(configs, count,
	vdev_cfg, name, &pool_guid);
	}
	}
	}
	g_topology_unlock();
	PICKUP_GIANT();

	return (*count > 0 ? 0 : ENOENT);
	}

	enum match {
	NO_MATCH = 0, /* No matching labels found */
	TOPGUID_MATCH = 1, /* Labels match top guid, not vdev guid */
	ZERO_MATCH = 1, /* Should never be returned */
	ONE_MATCH = 2, /* 1 label matching the vdev_guid */
	TWO_MATCH = 3, /* 2 label matching the vdev_guid */
	THREE_MATCH = 4, /* 3 label matching the vdev_guid */
	FULL_MATCH = 5 /* all labels match the vdev_guid */
	};

	static enum match
	vdev_attach_ok(vdev_t vd, struct g_provider pp)
	{
	nvlist_t *config;
	uint64_t pool_guid, top_guid, vdev_guid;
	struct g_consumer *cp;
	int nlabels;

	cp = vdev_geom_attach(pp, NULL, B_TRUE);
	if (cp == NULL) {
	ZFS_LOG(1, "Unable to attach tasting instance to %s.",
	pp->name);
	return (NO_MATCH);
	}
	g_topology_unlock();
	nlabels = vdev_geom_read_config(cp, &config);
	g_topology_lock();
	vdev_geom_detach(cp, B_TRUE);
	if (nlabels == 0) {
	ZFS_LOG(1, "Unable to read config from %s.", pp->name);
	return (NO_MATCH);
	}

	pool_guid = 0;
	(void) nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_GUID, &pool_guid);
	top_guid = 0;
	(void) nvlist_lookup_uint64(config, ZPOOL_CONFIG_TOP_GUID, &top_guid);
	vdev_guid = 0;
	(void) nvlist_lookup_uint64(config, ZPOOL_CONFIG_GUID, &vdev_guid);
	nvlist_free(config);

	/*
	* Check that the label's pool guid matches the desired guid.
	* Inactive spares and L2ARCs do not have any pool guid in the label.
	*/
	if (pool_guid != 0 && pool_guid != spa_guid(vd->vdev_spa)) {
	ZFS_LOG(1, "pool guid mismatch for provider %s: %ju != %ju.",
	pp->name,
	(uintmax_t)spa_guid(vd->vdev_spa), (uintmax_t)pool_guid);
	return (NO_MATCH);
	}

	/*
	* Check that the label's vdev guid matches the desired guid.
	* The second condition handles possible race on vdev detach, when
	* remaining vdev receives GUID of destroyed top level mirror vdev.
	*/
	if (vdev_guid == vd->vdev_guid) {
	ZFS_LOG(1, "guids match for provider %s.", pp->name);
	return (ZERO_MATCH + nlabels);
	} else if (top_guid == vd->vdev_guid && vd == vd->vdev_top) {
	ZFS_LOG(1, "top vdev guid match for provider %s.", pp->name);
	return (TOPGUID_MATCH);
	}
	ZFS_LOG(1, "vdev guid mismatch for provider %s: %ju != %ju.",
	pp->name, (uintmax_t)vd->vdev_guid, (uintmax_t)vdev_guid);
	return (NO_MATCH);
	}

	static struct g_consumer *
	vdev_geom_attach_by_guids(vdev_t *vd)
	{
	struct g_class *mp;
	struct g_geom *gp;
	struct g_provider pp, best_pp;
	struct g_consumer *cp;
	const char *vdpath;
	enum match match, best_match;

	g_topology_assert();

	vdpath = vd->vdev_path + sizeof ("/dev/") - 1;
	cp = NULL;
	best_pp = NULL;
	best_match = NO_MATCH;
	LIST_FOREACH(mp, &g_classes, class) {
	if (mp == &zfs_vdev_class)
	continue;
	LIST_FOREACH(gp, &mp->geom, geom) {
	if (gp->flags & G_GEOM_WITHER)
	continue;
	LIST_FOREACH(pp, &gp->provider, provider) {
	match = vdev_attach_ok(vd, pp);
	if (match > best_match) {
	best_match = match;
	best_pp = pp;
	} else if (match == best_match) {
	if (strcmp(pp->name, vdpath) == 0) {
	best_pp = pp;
	}
	}
	if (match == FULL_MATCH)
	goto out;
	}
	}
	}

	out:
	if (best_pp) {
	cp = vdev_geom_attach(best_pp, vd, B_TRUE);
	if (cp == NULL) {
	printf("ZFS WARNING: Unable to attach to %s.\n",
	best_pp->name);
	}
	}
	return (cp);
	}

	static struct g_consumer *
	vdev_geom_open_by_guids(vdev_t *vd)
	{
	struct g_consumer *cp;
	char *buf;
	size_t len;

	g_topology_assert();

	ZFS_LOG(1, "Searching by guids [%ju:%ju].",
	(uintmax_t)spa_guid(vd->vdev_spa), (uintmax_t)vd->vdev_guid);
	cp = vdev_geom_attach_by_guids(vd);
	if (cp != NULL) {
	len = strlen(cp->provider->name) + strlen("/dev/") + 1;
	buf = kmem_alloc(len, KM_SLEEP);

	snprintf(buf, len, "/dev/%s", cp->provider->name);
	spa_strfree(vd->vdev_path);
	vd->vdev_path = buf;

	ZFS_LOG(1, "Attach by guid [%ju:%ju] succeeded, provider %s.",
	(uintmax_t)spa_guid(vd->vdev_spa),
	(uintmax_t)vd->vdev_guid, cp->provider->name);
	} else {
	ZFS_LOG(1, "Search by guid [%ju:%ju] failed.",
	(uintmax_t)spa_guid(vd->vdev_spa),
	(uintmax_t)vd->vdev_guid);
	}

	return (cp);
	}

	static struct g_consumer *
	vdev_geom_open_by_path(vdev_t *vd, int check_guid)
	{
	struct g_provider *pp;
	struct g_consumer *cp;

	g_topology_assert();

	cp = NULL;
	pp = g_provider_by_name(vd->vdev_path + sizeof ("/dev/") - 1);
	if (pp != NULL) {
	ZFS_LOG(1, "Found provider by name %s.", vd->vdev_path);
	if (!check_guid \|\| vdev_attach_ok(vd, pp) == FULL_MATCH)
	cp = vdev_geom_attach(pp, vd, B_FALSE);
	}

	return (cp);
	}

	static int
	vdev_geom_open(vdev_t vd, uint64_t psize, uint64_t *max_psize,
	uint64_t logical_ashift, uint64_t physical_ashift)
	{
	struct g_provider *pp;
	struct g_consumer *cp;
	int error, has_trim;
	uint16_t rate;

	/*
	* Set the TLS to indicate downstack that we
	* should not access zvols
	*/
	VERIFY0(tsd_set(zfs_geom_probe_vdev_key, vd));

	/*
	* We must have a pathname, and it must be absolute.
	*/
	if (vd->vdev_path == NULL \|\| strncmp(vd->vdev_path, "/dev/", 5) != 0) {
	vd->vdev_stat.vs_aux = VDEV_AUX_BAD_LABEL;
	return (EINVAL);
	}

	/*
	* Reopen the device if it's not currently open. Otherwise,
	* just update the physical size of the device.
	*/
	if ((cp = vd->vdev_tsd) != NULL) {
	ASSERT(vd->vdev_reopening);
	goto skip_open;
	}

	DROP_GIANT();
	g_topology_lock();
	error = 0;

	if (vd->vdev_spa->spa_is_splitting \|\|
	((vd->vdev_prevstate == VDEV_STATE_UNKNOWN &&
	(vd->vdev_spa->spa_load_state == SPA_LOAD_NONE \|\|
	vd->vdev_spa->spa_load_state == SPA_LOAD_CREATE)))) {
	/*
	* We are dealing with a vdev that hasn't been previously
	* opened (since boot), and we are not loading an
	* existing pool configuration. This looks like a
	* vdev add operation to a new or existing pool.
	* Assume the user really wants to do this, and find
	* GEOM provider by its name, ignoring GUID mismatches.
	*
	* XXPOLICY: It would be safer to only allow a device
	* that is unlabeled or labeled but missing
	* GUID information to be opened in this fashion,
	* unless we are doing a split, in which case we
	* should allow any guid.
	*/
	cp = vdev_geom_open_by_path(vd, 0);
	} else {
	/*
	* Try using the recorded path for this device, but only
	* accept it if its label data contains the expected GUIDs.
	*/
	cp = vdev_geom_open_by_path(vd, 1);
	if (cp == NULL) {
	/*
	* The device at vd->vdev_path doesn't have the
	* expected GUIDs. The disks might have merely
	* moved around so try all other GEOM providers
	* to find one with the right GUIDs.
	*/
	cp = vdev_geom_open_by_guids(vd);
	}
	}

	/* Clear the TLS now that tasting is done */
	VERIFY0(tsd_set(zfs_geom_probe_vdev_key, NULL));

	if (cp == NULL) {
	ZFS_LOG(1, "Vdev %s not found.", vd->vdev_path);
	error = ENOENT;
	} else {
	struct consumer_priv_t *priv;
	struct consumer_vdev_elem *elem;
	int spamode;

	priv = (struct consumer_priv_t *)&cp->private;
	if (cp->private == NULL)
	SLIST_INIT(priv);
	elem = g_malloc(sizeof (*elem), M_WAITOK\|M_ZERO);
	elem->vd = vd;
	SLIST_INSERT_HEAD(priv, elem, elems);

	spamode = spa_mode(vd->vdev_spa);
	if (cp->provider->sectorsize > VDEV_PAD_SIZE \|\|
	!ISP2(cp->provider->sectorsize)) {
	ZFS_LOG(1, "Provider %s has unsupported sectorsize.",
	cp->provider->name);

	vdev_geom_close_locked(vd);
	error = EINVAL;
	cp = NULL;
	} else if (cp->acw == 0 && (spamode & FWRITE) != 0) {
	int i;

	for (i = 0; i < 5; i++) {
	error = g_access(cp, 0, 1, 0);
	if (error == 0)
	break;
	g_topology_unlock();
	tsleep(vd, 0, "vdev", hz / 2);
	g_topology_lock();
	}
	if (error != 0) {
	printf("ZFS WARNING: Unable to open %s for "
	"writing (error=%d).\n",
	cp->provider->name, error);
	vdev_geom_close_locked(vd);
	cp = NULL;
	}
	}
	}

	/* Fetch initial physical path information for this device. */
	if (cp != NULL) {
	vdev_geom_attrchanged(cp, "GEOM::physpath");

	/* Set other GEOM characteristics */
	vdev_geom_set_physpath(vd, cp, /* do_null_update */B_FALSE);
	}

	g_topology_unlock();
	PICKUP_GIANT();
	if (cp == NULL) {
	vd->vdev_stat.vs_aux = VDEV_AUX_OPEN_FAILED;
	vdev_dbgmsg(vd, "vdev_geom_open: failed to open [error=%d]",
	error);
	return (error);
	}
	skip_open:
	pp = cp->provider;

	/*
	* Determine the actual size of the device.
	*/
	max_psize = psize = pp->mediasize;

	/*
	* Determine the device's minimum transfer size and preferred
	* transfer size.
	*/
	*logical_ashift = highbit(MAX(pp->sectorsize, SPA_MINBLOCKSIZE)) - 1;
	*physical_ashift = 0;
	if (pp->stripesize && pp->stripesize > (1 << *logical_ashift) &&
	ISP2(pp->stripesize) && pp->stripesize <= (1 << ASHIFT_MAX) &&
	pp->stripeoffset == 0)
	*physical_ashift = highbit(pp->stripesize) - 1;

	/*
	* Clear the nowritecache settings, so that on a vdev_reopen()
	* we will try again.
	*/
	vd->vdev_nowritecache = B_FALSE;

	/* Inform the ZIO pipeline that we are non-rotational. */
	error = g_getattr("GEOM::rotation_rate", cp, &rate);
	if (error == 0 && rate == DISK_RR_NON_ROTATING)
	vd->vdev_nonrot = B_TRUE;
	else
	vd->vdev_nonrot = B_FALSE;

	/* Set when device reports it supports TRIM. */
	error = g_getattr("GEOM::candelete", cp, &has_trim);
	vd->vdev_has_trim = (error == 0 && has_trim);

	/* Set when device reports it supports secure TRIM. */
	/* unavailable on FreeBSD */
	vd->vdev_has_securetrim = B_FALSE;

	return (0);
	}

	static void
	vdev_geom_close(vdev_t *vd)
	{
	struct g_consumer *cp;
	boolean_t locked;

	cp = vd->vdev_tsd;

	DROP_GIANT();
	locked = g_topology_locked();
	if (!locked)
	g_topology_lock();

	if (!vd->vdev_reopening \|\|
	(cp != NULL && ((cp->flags & G_CF_ORPHAN) != 0 \|\|
	(cp->provider != NULL && cp->provider->error != 0))))
	vdev_geom_close_locked(vd);

	if (!locked)
	g_topology_unlock();
	PICKUP_GIANT();
	}

	static void
	vdev_geom_io_intr(struct bio *bp)
	{
	vdev_t *vd;
	zio_t *zio;

	zio = bp->bio_caller1;
	vd = zio->io_vd;
	zio->io_error = bp->bio_error;
	if (zio->io_error == 0 && bp->bio_resid != 0)
	zio->io_error = SET_ERROR(EIO);

	switch (zio->io_error) {
	case ENOTSUP:
	/*
	* If we get ENOTSUP for BIO_FLUSH or BIO_DELETE we know
	* that future attempts will never succeed. In this case
	* we set a persistent flag so that we don't bother with
	* requests in the future.
	*/
	switch (bp->bio_cmd) {
	case BIO_FLUSH:
	vd->vdev_nowritecache = B_TRUE;
	break;
	case BIO_DELETE:
	break;
	}
	break;
	case ENXIO:
	if (!vd->vdev_remove_wanted) {
	/*
	* If provider's error is set we assume it is being
	* removed.
	*/
	if (bp->bio_to->error != 0) {
	vd->vdev_remove_wanted = B_TRUE;
	spa_async_request(zio->io_spa,
	SPA_ASYNC_REMOVE);
	} else if (!vd->vdev_delayed_close) {
	vd->vdev_delayed_close = B_TRUE;
	}
	}
	break;
	}

	/*
	* We have to split bio freeing into two parts, because the ABD code
	* cannot be called in this context and vdev_op_io_done is not called
	* for ZIO_TYPE_IOCTL zio-s.
	*/
	if (zio->io_type != ZIO_TYPE_READ && zio->io_type != ZIO_TYPE_WRITE) {
	g_destroy_bio(bp);
	zio->io_bio = NULL;
	}
	zio_delay_interrupt(zio);
	}

	struct vdev_geom_check_unmapped_cb_state {
	int pages;
	uint_t end;
	};

	/*
	* Callback to check the ABD segment size/alignment and count the pages.
	* GEOM requires data buffer to look virtually contiguous. It means only
	* the first page of the buffer may not start and only the last may not
	* end on a page boundary. All other physical pages must be full.
	*/
	static int
	vdev_geom_check_unmapped_cb(void buf, size_t len, void priv)
	{
	struct vdev_geom_check_unmapped_cb_state *s = priv;
	vm_offset_t off = (vm_offset_t)buf & PAGE_MASK;

	if (s->pages != 0 && off != 0)
	return (1);
	if (s->end != 0)
	return (1);
	s->end = (off + len) & PAGE_MASK;
	s->pages += (off + len + PAGE_MASK) >> PAGE_SHIFT;
	return (0);
	}

	/*
	* Check whether we can use unmapped I/O for this ZIO on this device to
	* avoid data copying between scattered and/or gang ABD buffer and linear.
	*/
	static int
	vdev_geom_check_unmapped(zio_t zio, struct g_consumer cp)
	{
	struct vdev_geom_check_unmapped_cb_state s;

	/* If unmapped I/O is administratively disabled, respect that. */
	if (!unmapped_buf_allowed)
	return (0);

	/* If the buffer is already linear, then nothing to do here. */
	if (abd_is_linear(zio->io_abd))
	return (0);

	/*
	* If unmapped I/O is not supported by the GEOM provider,
	* then we can't do anything and have to copy the data.
	*/
	if ((cp->provider->flags & G_PF_ACCEPT_UNMAPPED) == 0)
	return (0);

	/* Check the buffer chunks sizes/alignments and count pages. */
	s.pages = s.end = 0;
	if (abd_iterate_func(zio->io_abd, 0, zio->io_size,
	vdev_geom_check_unmapped_cb, &s))
	return (0);
	return (s.pages);
	}

	/*
	* Callback to translate the ABD segment into array of physical pages.
	*/
	static int
	vdev_geom_fill_unmap_cb(void buf, size_t len, void priv)
	{
	struct bio *bp = priv;
	vm_offset_t addr = (vm_offset_t)buf;
	vm_offset_t end = addr + len;

	if (bp->bio_ma_n == 0)
	bp->bio_ma_offset = addr & PAGE_MASK;
	do {
	bp->bio_ma[bp->bio_ma_n++] =
	PHYS_TO_VM_PAGE(pmap_kextract(addr));
	addr += PAGE_SIZE;
	} while (addr < end);
	return (0);
	}

	static void
	vdev_geom_io_start(zio_t *zio)
	{
	vdev_t *vd;
	struct g_consumer *cp;
	struct bio *bp;

	vd = zio->io_vd;

	switch (zio->io_type) {
	case ZIO_TYPE_IOCTL:
	/* XXPOLICY */
	if (!vdev_readable(vd)) {
	zio->io_error = SET_ERROR(ENXIO);
	zio_interrupt(zio);
	return;
	} else {
	switch (zio->io_cmd) {
	case DKIOCFLUSHWRITECACHE:
	if (zfs_nocacheflush \|\|
	vdev_geom_bio_flush_disable)
	break;
	if (vd->vdev_nowritecache) {
	zio->io_error = SET_ERROR(ENOTSUP);
	break;
	}
	goto sendreq;
	default:
	zio->io_error = SET_ERROR(ENOTSUP);
	}
	}

	zio_execute(zio);
	return;
	case ZIO_TYPE_TRIM:
	if (!vdev_geom_bio_delete_disable) {
	goto sendreq;
	}
	zio_execute(zio);
	return;
	default:
	;
	/* PASSTHROUGH --- placate compiler */
	}
	sendreq:
	ASSERT(zio->io_type == ZIO_TYPE_READ \|\|
	zio->io_type == ZIO_TYPE_WRITE \|\|
	zio->io_type == ZIO_TYPE_TRIM \|\|
	zio->io_type == ZIO_TYPE_IOCTL);

	cp = vd->vdev_tsd;
	if (cp == NULL) {
	zio->io_error = SET_ERROR(ENXIO);
	zio_interrupt(zio);
	return;
	}
	bp = g_alloc_bio();
	bp->bio_caller1 = zio;
	switch (zio->io_type) {
	case ZIO_TYPE_READ:
	case ZIO_TYPE_WRITE:
	zio->io_target_timestamp = zio_handle_io_delay(zio);
	bp->bio_offset = zio->io_offset;
	bp->bio_length = zio->io_size;
	if (zio->io_type == ZIO_TYPE_READ)
	bp->bio_cmd = BIO_READ;
	else
	bp->bio_cmd = BIO_WRITE;

	/*
	* If possible, represent scattered and/or gang ABD buffer to
	* GEOM as an array of physical pages. It allows to satisfy
	* requirement of virtually contiguous buffer without copying.
	*/
	int pgs = vdev_geom_check_unmapped(zio, cp);
	if (pgs > 0) {
	bp->bio_ma = malloc(sizeof (struct vm_page ) pgs,
	M_DEVBUF, M_WAITOK);
	bp->bio_ma_n = 0;
	bp->bio_ma_offset = 0;
	abd_iterate_func(zio->io_abd, 0, zio->io_size,
	vdev_geom_fill_unmap_cb, bp);
	bp->bio_data = unmapped_buf;
	bp->bio_flags \|= BIO_UNMAPPED;
	} else {
	if (zio->io_type == ZIO_TYPE_READ) {
	bp->bio_data = abd_borrow_buf(zio->io_abd,
	zio->io_size);
	} else {
	bp->bio_data = abd_borrow_buf_copy(zio->io_abd,
	zio->io_size);
	}
	}
	break;
	case ZIO_TYPE_TRIM:
	bp->bio_cmd = BIO_DELETE;
	bp->bio_data = NULL;
	bp->bio_offset = zio->io_offset;
	bp->bio_length = zio->io_size;
	break;
	case ZIO_TYPE_IOCTL:
	bp->bio_cmd = BIO_FLUSH;
	bp->bio_data = NULL;
	bp->bio_offset = cp->provider->mediasize;
	bp->bio_length = 0;
	break;
	default:
	panic("invalid zio->io_type: %d\n", zio->io_type);
	}
	bp->bio_done = vdev_geom_io_intr;
	zio->io_bio = bp;

	g_io_request(bp, cp);
	}

	static void
	vdev_geom_io_done(zio_t *zio)
	{
	struct bio *bp = zio->io_bio;

	if (zio->io_type != ZIO_TYPE_READ && zio->io_type != ZIO_TYPE_WRITE) {
	ASSERT3P(bp, ==, NULL);
	return;
	}

	if (bp == NULL) {
	ASSERT3S(zio->io_error, ==, ENXIO);
	return;
	}

	if (bp->bio_ma != NULL) {
	free(bp->bio_ma, M_DEVBUF);
	} else {
	if (zio->io_type == ZIO_TYPE_READ) {
	abd_return_buf_copy(zio->io_abd, bp->bio_data,
	zio->io_size);
	} else {
	abd_return_buf(zio->io_abd, bp->bio_data,
	zio->io_size);
	}
	}

	g_destroy_bio(bp);
	zio->io_bio = NULL;
	}

	static void
	vdev_geom_hold(vdev_t *vd)
	{
	}

	static void
	vdev_geom_rele(vdev_t *vd)
	{
	}

	vdev_ops_t vdev_disk_ops = {
	.vdev_op_init = NULL,
	.vdev_op_fini = NULL,
	.vdev_op_open = vdev_geom_open,
	.vdev_op_close = vdev_geom_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_geom_io_start,
	.vdev_op_io_done = vdev_geom_io_done,
	.vdev_op_state_change = NULL,
	.vdev_op_need_resilver = NULL,
	.vdev_op_hold = vdev_geom_hold,
	.vdev_op_rele = vdev_geom_rele,
	.vdev_op_remap = NULL,
	.vdev_op_xlate = vdev_default_xlate,
	.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_DISK, /* name of this vdev type */
	.vdev_op_leaf = B_TRUE /* leaf vdev */
	};
	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 9b410863019e..ae758bcefe21 100644
	--- a/sys/contrib/openzfs/module/os/freebsd/zfs/zfs_acl.c
	+++ b/sys/contrib/openzfs/module/os/freebsd/zfs/zfs_acl.c
	@@ -1,2672 +1,2672 @@
	/*
	* 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/
	+ 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);
	VERIFY3S(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);
	VERIFY3S(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;

	ASSERT3P(aclp, !=, NULL);

	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;

	ASSERT3U(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;
	VERIFY0(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));
	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);
	ASSERT3U(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) {
	data2sz = aclp->z_ops->ace_data(acep, &data2);
	VERIFY3U(data2sz, ==, 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
	ASSERT3P(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;
	}
	ASSERT3U((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);
	ASSERT0(error);
	ASSERT3P(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);
	}

	ASSERT3P(zp->z_acl_cached, !=, NULL);

	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/
	+ 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));

	/*
	* 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);

	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;
	ASSERT3U(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);
	ASSERT(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_ctldir.c b/sys/contrib/openzfs/module/os/freebsd/zfs/zfs_ctldir.c
	index a9fe1b647238..cde40e87698b 100644
	--- a/sys/contrib/openzfs/module/os/freebsd/zfs/zfs_ctldir.c
	+++ b/sys/contrib/openzfs/module/os/freebsd/zfs/zfs_ctldir.c
	@@ -1,1361 +1,1370 @@
	/*
	* 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 2015, OmniTI Computer Consulting, Inc. All rights reserved.
	*/

	/*
	* ZFS control directory (a.k.a. ".zfs")
	*
	* This directory provides a common location for all ZFS meta-objects.
	* Currently, this is only the 'snapshot' directory, but this may expand in the
	* future. The elements are built using the GFS primitives, as the hierarchy
	* does not actually exist on disk.
	*
	* For 'snapshot', we don't want to have all snapshots always mounted, because
	* this would take up a huge amount of space in /etc/mnttab. We have three
	* types of objects:
	*
	* ctldir ------> snapshotdir -------> snapshot
	* \|
	* \|
	* V
	* mounted fs
	*
	* The 'snapshot' node contains just enough information to lookup '..' and act
	* as a mountpoint for the snapshot. Whenever we lookup a specific snapshot, we
	* perform an automount of the underlying filesystem and return the
	* corresponding vnode.
	*
	* All mounts are handled automatically by the kernel, but unmounts are
	* (currently) handled from user land. The main reason is that there is no
	* reliable way to auto-unmount the filesystem when it's "no longer in use".
	* When the user unmounts a filesystem, we call zfsctl_unmount(), which
	* unmounts any snapshots within the snapshot directory.
	*
	* The '.zfs', '.zfs/snapshot', and all directories created under
	* '.zfs/snapshot' (ie: '.zfs/snapshot/<snapname>') are all GFS nodes and
	* share the same vfs_t as the head filesystem (what '.zfs' lives under).
	*
	* File systems mounted ontop of the GFS nodes '.zfs/snapshot/<snapname>'
	* (ie: snapshots) are ZFS nodes and have their own unique vfs_t.
	* However, vnodes within these mounted on file systems have their v_vfsp
	* fields set to the head filesystem to make NFS happy (see
	* zfsctl_snapdir_lookup()). We VFS_HOLD the head filesystem's vfs_t
	* so that it cannot be freed until all snapshots have been unmounted.
	*/

	#include <sys/types.h>
	#include <sys/param.h>
	#include <sys/libkern.h>
	#include <sys/dirent.h>
	#include <sys/zfs_context.h>
	#include <sys/zfs_ctldir.h>
	#include <sys/zfs_ioctl.h>
	#include <sys/zfs_vfsops.h>
	#include <sys/namei.h>
	#include <sys/stat.h>
	#include <sys/dmu.h>
	#include <sys/dsl_dataset.h>
	#include <sys/dsl_destroy.h>
	#include <sys/dsl_deleg.h>
	#include <sys/mount.h>
	#include <sys/zap.h>
	#include <sys/sysproto.h>

	#include "zfs_namecheck.h"

	#include <sys/kernel.h>
	#include <sys/ccompat.h>

	/* Common access mode for all virtual directories under the ctldir */
	const uint16_t zfsctl_ctldir_mode = S_IRUSR \| S_IXUSR \| S_IRGRP \| S_IXGRP \|
	S_IROTH \| S_IXOTH;

	/*
	* "Synthetic" filesystem implementation.
	*/

	/*
	* Assert that A implies B.
	*/
	#define KASSERT_IMPLY(A, B, msg) KASSERT(!(A) \|\| (B), (msg));

	static MALLOC_DEFINE(M_SFSNODES, "sfs_nodes", "synthetic-fs nodes");

	typedef struct sfs_node {
	char sn_name[ZFS_MAX_DATASET_NAME_LEN];
	uint64_t sn_parent_id;
	uint64_t sn_id;
	} sfs_node_t;

	/*
	* Check the parent's ID as well as the node's to account for a chance
	* that IDs originating from different domains (snapshot IDs, artificial
	* IDs, znode IDs) may clash.
	*/
	static int
	sfs_compare_ids(struct vnode vp, void arg)
	{
	sfs_node_t *n1 = vp->v_data;
	sfs_node_t *n2 = arg;
	bool equal;

	equal = n1->sn_id == n2->sn_id &&
	n1->sn_parent_id == n2->sn_parent_id;

	/* Zero means equality. */
	return (!equal);
	}

	static int
	sfs_vnode_get(const struct mount *mp, int flags, uint64_t parent_id,
	uint64_t id, struct vnode **vpp)
	{
	sfs_node_t search;
	int err;

	search.sn_id = id;
	search.sn_parent_id = parent_id;
	err = vfs_hash_get(mp, (uint32_t)id, flags, curthread, vpp,
	sfs_compare_ids, &search);
	return (err);
	}

	static int
	sfs_vnode_insert(struct vnode *vp, int flags, uint64_t parent_id,
	uint64_t id, struct vnode **vpp)
	{
	int err;

	KASSERT(vp->v_data != NULL, ("sfs_vnode_insert with NULL v_data"));
	err = vfs_hash_insert(vp, (uint32_t)id, flags, curthread, vpp,
	sfs_compare_ids, vp->v_data);
	return (err);
	}

	static void
	sfs_vnode_remove(struct vnode *vp)
	{
	vfs_hash_remove(vp);
	}

	typedef void sfs_vnode_setup_fn(vnode_t vp, void arg);

	static int
	sfs_vgetx(struct mount *mp, int flags, uint64_t parent_id, uint64_t id,
	const char tag, struct vop_vector vops,
	sfs_vnode_setup_fn setup, void *arg,
	struct vnode **vpp)
	{
	struct vnode *vp;
	int error;

	error = sfs_vnode_get(mp, flags, parent_id, id, vpp);
	if (error != 0 \|\| *vpp != NULL) {
	KASSERT_IMPLY(error == 0, (*vpp)->v_data != NULL,
	"sfs vnode with no data");
	return (error);
	}

	/* Allocate a new vnode/inode. */
	error = getnewvnode(tag, mp, vops, &vp);
	if (error != 0) {
	*vpp = NULL;
	return (error);
	}

	/*
	* Exclusively lock the vnode vnode while it's being constructed.
	*/
	lockmgr(vp->v_vnlock, LK_EXCLUSIVE, NULL);
	error = insmntque(vp, mp);
	if (error != 0) {
	*vpp = NULL;
	return (error);
	}

	setup(vp, arg);

	error = sfs_vnode_insert(vp, flags, parent_id, id, vpp);
	if (error != 0 \|\| *vpp != NULL) {
	KASSERT_IMPLY(error == 0, (*vpp)->v_data != NULL,
	"sfs vnode with no data");
	return (error);
	}

	*vpp = vp;
	return (0);
	}

	static void
	sfs_print_node(sfs_node_t *node)
	{
	printf("\tname = %s\n", node->sn_name);
	printf("\tparent_id = %ju\n", (uintmax_t)node->sn_parent_id);
	printf("\tid = %ju\n", (uintmax_t)node->sn_id);
	}

	static sfs_node_t *
	sfs_alloc_node(size_t size, const char *name, uint64_t parent_id, uint64_t id)
	{
	struct sfs_node *node;

	KASSERT(strlen(name) < sizeof (node->sn_name),
	("sfs node name is too long"));
	KASSERT(size >= sizeof (*node), ("sfs node size is too small"));
	node = malloc(size, M_SFSNODES, M_WAITOK \| M_ZERO);
	strlcpy(node->sn_name, name, sizeof (node->sn_name));
	node->sn_parent_id = parent_id;
	node->sn_id = id;

	return (node);
	}

	static void
	sfs_destroy_node(sfs_node_t *node)
	{
	free(node, M_SFSNODES);
	}

	static void *
	sfs_reclaim_vnode(vnode_t *vp)
	{
	void *data;

	sfs_vnode_remove(vp);
	data = vp->v_data;
	vp->v_data = NULL;
	return (data);
	}

	static int
	sfs_readdir_common(uint64_t parent_id, uint64_t id, struct vop_readdir_args *ap,
	zfs_uio_t uio, off_t offp)
	{
	struct dirent entry;
	int error;

	/* Reset ncookies for subsequent use of vfs_read_dirent. */
	if (ap->a_ncookies != NULL)
	*ap->a_ncookies = 0;

	if (zfs_uio_resid(uio) < sizeof (entry))
	return (SET_ERROR(EINVAL));

	if (zfs_uio_offset(uio) < 0)
	return (SET_ERROR(EINVAL));
	if (zfs_uio_offset(uio) == 0) {
	entry.d_fileno = id;
	entry.d_type = DT_DIR;
	entry.d_name[0] = '.';
	entry.d_name[1] = '\0';
	entry.d_namlen = 1;
	entry.d_reclen = sizeof (entry);
	error = vfs_read_dirent(ap, &entry, zfs_uio_offset(uio));
	if (error != 0)
	return (SET_ERROR(error));
	}

	if (zfs_uio_offset(uio) < sizeof (entry))
	return (SET_ERROR(EINVAL));
	if (zfs_uio_offset(uio) == sizeof (entry)) {
	entry.d_fileno = parent_id;
	entry.d_type = DT_DIR;
	entry.d_name[0] = '.';
	entry.d_name[1] = '.';
	entry.d_name[2] = '\0';
	entry.d_namlen = 2;
	entry.d_reclen = sizeof (entry);
	error = vfs_read_dirent(ap, &entry, zfs_uio_offset(uio));
	if (error != 0)
	return (SET_ERROR(error));
	}

	if (offp != NULL)
	offp = 2 sizeof (entry);
	return (0);
	}


	/*
	* .zfs inode namespace
	*
	* We need to generate unique inode numbers for all files and directories
	* within the .zfs pseudo-filesystem. We use the following scheme:
	*
	* ENTRY ZFSCTL_INODE
	* .zfs 1
	* .zfs/snapshot 2
	* .zfs/snapshot/<snap> objectid(snap)
	*/
	#define ZFSCTL_INO_SNAP(id) (id)

	static struct vop_vector zfsctl_ops_root;
	static struct vop_vector zfsctl_ops_snapdir;
	static struct vop_vector zfsctl_ops_snapshot;

	void
	zfsctl_init(void)
	{
	}

	void
	zfsctl_fini(void)
	{
	}

	boolean_t
	zfsctl_is_node(vnode_t *vp)
	{
	return (vn_matchops(vp, zfsctl_ops_root) \|\|
	vn_matchops(vp, zfsctl_ops_snapdir) \|\|
	vn_matchops(vp, zfsctl_ops_snapshot));

	}

	typedef struct zfsctl_root {
	sfs_node_t node;
	sfs_node_t *snapdir;
	timestruc_t cmtime;
	} zfsctl_root_t;


	/*
	* Create the '.zfs' directory.
	*/
	void
	zfsctl_create(zfsvfs_t *zfsvfs)
	{
	zfsctl_root_t *dot_zfs;
	sfs_node_t *snapdir;
	vnode_t *rvp;
	uint64_t crtime[2];

	ASSERT3P(zfsvfs->z_ctldir, ==, NULL);

	snapdir = sfs_alloc_node(sizeof (*snapdir), "snapshot", ZFSCTL_INO_ROOT,
	ZFSCTL_INO_SNAPDIR);
	dot_zfs = (zfsctl_root_t )sfs_alloc_node(sizeof (dot_zfs), ".zfs", 0,
	ZFSCTL_INO_ROOT);
	dot_zfs->snapdir = snapdir;

	VERIFY0(VFS_ROOT(zfsvfs->z_vfs, LK_EXCLUSIVE, &rvp));
	VERIFY0(sa_lookup(VTOZ(rvp)->z_sa_hdl, SA_ZPL_CRTIME(zfsvfs),
	&crtime, sizeof (crtime)));
	ZFS_TIME_DECODE(&dot_zfs->cmtime, crtime);
	vput(rvp);

	zfsvfs->z_ctldir = dot_zfs;
	}

	/*
	* Destroy the '.zfs' directory. Only called when the filesystem is unmounted.
	* The nodes must not have any associated vnodes by now as they should be
	* vflush-ed.
	*/
	void
	zfsctl_destroy(zfsvfs_t *zfsvfs)
	{
	sfs_destroy_node(zfsvfs->z_ctldir->snapdir);
	sfs_destroy_node((sfs_node_t *)zfsvfs->z_ctldir);
	zfsvfs->z_ctldir = NULL;
	}

	static int
	zfsctl_fs_root_vnode(struct mount mp, void arg __unused, int flags,
	struct vnode **vpp)
	{
	return (VFS_ROOT(mp, flags, vpp));
	}

	static void
	zfsctl_common_vnode_setup(vnode_t vp, void arg)
	{
	ASSERT_VOP_ELOCKED(vp, __func__);

	/* We support shared locking. */
	VN_LOCK_ASHARE(vp);
	vp->v_type = VDIR;
	vp->v_data = arg;
	}

	static int
	zfsctl_root_vnode(struct mount mp, void arg __unused, int flags,
	struct vnode **vpp)
	{
	void *node;
	int err;

	node = ((zfsvfs_t *)mp->mnt_data)->z_ctldir;
	err = sfs_vgetx(mp, flags, 0, ZFSCTL_INO_ROOT, "zfs", &zfsctl_ops_root,
	zfsctl_common_vnode_setup, node, vpp);
	return (err);
	}

	static int
	zfsctl_snapdir_vnode(struct mount mp, void arg __unused, int flags,
	struct vnode **vpp)
	{
	void *node;
	int err;

	node = ((zfsvfs_t *)mp->mnt_data)->z_ctldir->snapdir;
	err = sfs_vgetx(mp, flags, ZFSCTL_INO_ROOT, ZFSCTL_INO_SNAPDIR, "zfs",
	&zfsctl_ops_snapdir, zfsctl_common_vnode_setup, node, vpp);
	return (err);
	}

	/*
	* Given a root znode, retrieve the associated .zfs directory.
	* Add a hold to the vnode and return it.
	*/
	int
	zfsctl_root(zfsvfs_t zfsvfs, int flags, vnode_t *vpp)
	{
	int error;

	error = zfsctl_root_vnode(zfsvfs->z_vfs, NULL, flags, vpp);
	return (error);
	}

	/*
	* Common open routine. Disallow any write access.
	*/
	static int
	zfsctl_common_open(struct vop_open_args *ap)
	{
	int flags = ap->a_mode;

	if (flags & FWRITE)
	return (SET_ERROR(EACCES));

	return (0);
	}

	/*
	* Common close routine. Nothing to do here.
	*/
	/* ARGSUSED */
	static int
	zfsctl_common_close(struct vop_close_args *ap)
	{
	return (0);
	}

	/*
	* Common access routine. Disallow writes.
	*/
	static int
	zfsctl_common_access(struct vop_access_args *ap)
	{
	accmode_t accmode = ap->a_accmode;

	if (accmode & VWRITE)
	return (SET_ERROR(EACCES));
	return (0);
	}

	/*
	* Common getattr function. Fill in basic information.
	*/
	static void
	zfsctl_common_getattr(vnode_t vp, vattr_t vap)
	{
	timestruc_t now;
	sfs_node_t *node;

	node = vp->v_data;

	vap->va_uid = 0;
	vap->va_gid = 0;
	vap->va_rdev = 0;
	/*
	* We are a purely virtual object, so we have no
	* blocksize or allocated blocks.
	*/
	vap->va_blksize = 0;
	vap->va_nblocks = 0;
	vap->va_seq = 0;
	vn_fsid(vp, vap);
	vap->va_mode = zfsctl_ctldir_mode;
	vap->va_type = VDIR;
	/*
	* We live in the now (for atime).
	*/
	gethrestime(&now);
	vap->va_atime = now;
	/* FreeBSD: Reset chflags(2) flags. */
	vap->va_flags = 0;

	vap->va_nodeid = node->sn_id;

	/* At least '.' and '..'. */
	vap->va_nlink = 2;
	}

	#ifndef _OPENSOLARIS_SYS_VNODE_H_
	struct vop_fid_args {
	struct vnode *a_vp;
	struct fid *a_fid;
	};
	#endif

	static int
	zfsctl_common_fid(struct vop_fid_args *ap)
	{
	vnode_t *vp = ap->a_vp;
	fid_t fidp = (void )ap->a_fid;
	sfs_node_t *node = vp->v_data;
	uint64_t object = node->sn_id;
	zfid_short_t *zfid;
	int i;

	zfid = (zfid_short_t *)fidp;
	zfid->zf_len = SHORT_FID_LEN;

	for (i = 0; i < sizeof (zfid->zf_object); i++)
	zfid->zf_object[i] = (uint8_t)(object >> (8 * i));

	/* .zfs nodes always have a generation number of 0 */
	for (i = 0; i < sizeof (zfid->zf_gen); i++)
	zfid->zf_gen[i] = 0;

	return (0);
	}

	#ifndef _SYS_SYSPROTO_H_
	struct vop_reclaim_args {
	struct vnode *a_vp;
	struct thread *a_td;
	};
	#endif

	static int
	zfsctl_common_reclaim(struct vop_reclaim_args *ap)
	{
	vnode_t *vp = ap->a_vp;

	(void) sfs_reclaim_vnode(vp);
	return (0);
	}

	#ifndef _SYS_SYSPROTO_H_
	struct vop_print_args {
	struct vnode *a_vp;
	};
	#endif

	static int
	zfsctl_common_print(struct vop_print_args *ap)
	{
	sfs_print_node(ap->a_vp->v_data);
	return (0);
	}

	#ifndef _SYS_SYSPROTO_H_
	struct vop_getattr_args {
	struct vnode *a_vp;
	struct vattr *a_vap;
	struct ucred *a_cred;
	};
	#endif

	/*
	* Get root directory attributes.
	*/
	static int
	zfsctl_root_getattr(struct vop_getattr_args *ap)
	{
	struct vnode *vp = ap->a_vp;
	struct vattr *vap = ap->a_vap;
	zfsctl_root_t *node = vp->v_data;

	zfsctl_common_getattr(vp, vap);
	vap->va_ctime = node->cmtime;
	vap->va_mtime = vap->va_ctime;
	vap->va_birthtime = vap->va_ctime;
	vap->va_nlink += 1; /* snapdir */
	vap->va_size = vap->va_nlink;
	return (0);
	}

	/*
	* When we lookup "." we still can be asked to lock it
	* differently, can't we?
	*/
	static int
	zfsctl_relock_dot(vnode_t *dvp, int ltype)
	{
	vref(dvp);
	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 may left us with reclaimed vnode. */
	if (VN_IS_DOOMED(dvp)) {
	vrele(dvp);
	return (SET_ERROR(ENOENT));
	}
	}
	return (0);
	}

	/*
	* Special case the handling of "..".
	*/
	static int
	zfsctl_root_lookup(struct vop_lookup_args *ap)
	{
	struct componentname *cnp = ap->a_cnp;
	vnode_t *dvp = ap->a_dvp;
	vnode_t **vpp = ap->a_vpp;
	int flags = ap->a_cnp->cn_flags;
	int lkflags = ap->a_cnp->cn_lkflags;
	int nameiop = ap->a_cnp->cn_nameiop;
	int err;

	ASSERT3S(dvp->v_type, ==, VDIR);

	if ((flags & ISLASTCN) != 0 && nameiop != LOOKUP)
	return (SET_ERROR(ENOTSUP));

	if (cnp->cn_namelen == 1 && *cnp->cn_nameptr == '.') {
	err = zfsctl_relock_dot(dvp, lkflags & LK_TYPE_MASK);
	if (err == 0)
	*vpp = dvp;
	} else if ((flags & ISDOTDOT) != 0) {
	err = vn_vget_ino_gen(dvp, zfsctl_fs_root_vnode, NULL,
	lkflags, vpp);
	} else if (strncmp(cnp->cn_nameptr, "snapshot", cnp->cn_namelen) == 0) {
	err = zfsctl_snapdir_vnode(dvp->v_mount, NULL, lkflags, vpp);
	} else {
	err = SET_ERROR(ENOENT);
	}
	if (err != 0)
	*vpp = NULL;
	return (err);
	}

	static int
	zfsctl_root_readdir(struct vop_readdir_args *ap)
	{
	struct dirent entry;
	vnode_t *vp = ap->a_vp;
	zfsvfs_t *zfsvfs = vp->v_vfsp->vfs_data;
	zfsctl_root_t *node = vp->v_data;
	zfs_uio_t uio;
	int *eofp = ap->a_eofflag;
	off_t dots_offset;
	int error;

	zfs_uio_init(&uio, ap->a_uio);

	ASSERT3S(vp->v_type, ==, VDIR);

	error = sfs_readdir_common(zfsvfs->z_root, ZFSCTL_INO_ROOT, ap, &uio,
	&dots_offset);
	if (error != 0) {
	if (error == ENAMETOOLONG) /* ran out of destination space */
	error = 0;
	return (error);
	}
	if (zfs_uio_offset(&uio) != dots_offset)
	return (SET_ERROR(EINVAL));

	CTASSERT(sizeof (node->snapdir->sn_name) <= sizeof (entry.d_name));
	entry.d_fileno = node->snapdir->sn_id;
	entry.d_type = DT_DIR;
	strcpy(entry.d_name, node->snapdir->sn_name);
	entry.d_namlen = strlen(entry.d_name);
	entry.d_reclen = sizeof (entry);
	error = vfs_read_dirent(ap, &entry, zfs_uio_offset(&uio));
	if (error != 0) {
	if (error == ENAMETOOLONG)
	error = 0;
	return (SET_ERROR(error));
	}
	if (eofp != NULL)
	*eofp = 1;
	return (0);
	}

	static int
	zfsctl_root_vptocnp(struct vop_vptocnp_args *ap)
	{
	static const char dotzfs_name[4] = ".zfs";
	vnode_t *dvp;
	int error;

	if (*ap->a_buflen < sizeof (dotzfs_name))
	return (SET_ERROR(ENOMEM));

	error = vn_vget_ino_gen(ap->a_vp, zfsctl_fs_root_vnode, NULL,
	LK_SHARED, &dvp);
	if (error != 0)
	return (SET_ERROR(error));

	VOP_UNLOCK1(dvp);
	*ap->a_vpp = dvp;
	*ap->a_buflen -= sizeof (dotzfs_name);
	bcopy(dotzfs_name, ap->a_buf + *ap->a_buflen, sizeof (dotzfs_name));
	return (0);
	}

	static int
	zfsctl_common_pathconf(struct vop_pathconf_args *ap)
	{
	/*
	* We care about ACL variables so that user land utilities like ls
	* can display them correctly. Since the ctldir's st_dev is set to be
	* the same as the parent dataset, we must support all variables that
	* it supports.
	*/
	switch (ap->a_name) {
	case _PC_LINK_MAX:
	*ap->a_retval = MIN(LONG_MAX, ZFS_LINK_MAX);
	return (0);

	case _PC_FILESIZEBITS:
	*ap->a_retval = 64;
	return (0);

	case _PC_MIN_HOLE_SIZE:
	*ap->a_retval = (int)SPA_MINBLOCKSIZE;
	return (0);

	case _PC_ACL_EXTENDED:
	*ap->a_retval = 0;
	return (0);

	case _PC_ACL_NFS4:
	*ap->a_retval = 1;
	return (0);

	case _PC_ACL_PATH_MAX:
	*ap->a_retval = ACL_MAX_ENTRIES;
	return (0);

	case _PC_NAME_MAX:
	*ap->a_retval = NAME_MAX;
	return (0);

	default:
	return (vop_stdpathconf(ap));
	}
	}

	/*
	* Returns a trivial ACL
	*/
	static int
	zfsctl_common_getacl(struct vop_getacl_args *ap)
	{
	int i;

	if (ap->a_type != ACL_TYPE_NFS4)
	return (EINVAL);

	acl_nfs4_sync_acl_from_mode(ap->a_aclp, zfsctl_ctldir_mode, 0);
	/*
	* acl_nfs4_sync_acl_from_mode assumes that the owner can always modify
	* attributes. That is not the case for the ctldir, so we must clear
	* those bits. We also must clear ACL_READ_NAMED_ATTRS, because xattrs
	* aren't supported by the ctldir.
	*/
	for (i = 0; i < ap->a_aclp->acl_cnt; i++) {
	struct acl_entry *entry;
	entry = &(ap->a_aclp->acl_entry[i]);
	entry->ae_perm &= ~(ACL_WRITE_ACL \| ACL_WRITE_OWNER \|
	ACL_WRITE_ATTRIBUTES \| ACL_WRITE_NAMED_ATTRS \|
	ACL_READ_NAMED_ATTRS);
	}

	return (0);
	}

	static struct vop_vector zfsctl_ops_root = {
	.vop_default = &default_vnodeops,
	#if __FreeBSD_version >= 1300121
	.vop_fplookup_vexec = VOP_EAGAIN,
	#endif
	.vop_open = zfsctl_common_open,
	.vop_close = zfsctl_common_close,
	.vop_ioctl = VOP_EINVAL,
	.vop_getattr = zfsctl_root_getattr,
	.vop_access = zfsctl_common_access,
	.vop_readdir = zfsctl_root_readdir,
	.vop_lookup = zfsctl_root_lookup,
	.vop_inactive = VOP_NULL,
	.vop_reclaim = zfsctl_common_reclaim,
	.vop_fid = zfsctl_common_fid,
	.vop_print = zfsctl_common_print,
	.vop_vptocnp = zfsctl_root_vptocnp,
	.vop_pathconf = zfsctl_common_pathconf,
	.vop_getacl = zfsctl_common_getacl,
	+#if __FreeBSD_version >= 1400043
	+ .vop_add_writecount = vop_stdadd_writecount_nomsync,
	+#endif
	};
	VFS_VOP_VECTOR_REGISTER(zfsctl_ops_root);

	static int
	zfsctl_snapshot_zname(vnode_t vp, const char name, int len, char *zname)
	{
	objset_t os = ((zfsvfs_t )((vp)->v_vfsp->vfs_data))->z_os;

	dmu_objset_name(os, zname);
	if (strlen(zname) + 1 + strlen(name) >= len)
	return (SET_ERROR(ENAMETOOLONG));
	(void) strcat(zname, "@");
	(void) strcat(zname, name);
	return (0);
	}

	static int
	zfsctl_snapshot_lookup(vnode_t vp, const char name, uint64_t *id)
	{
	objset_t os = ((zfsvfs_t )((vp)->v_vfsp->vfs_data))->z_os;
	int err;

	err = dsl_dataset_snap_lookup(dmu_objset_ds(os), name, id);
	return (err);
	}

	/*
	* Given a vnode get a root vnode of a filesystem mounted on top of
	* the vnode, if any. The root vnode is referenced and locked.
	* If no filesystem is mounted then the orinal vnode remains referenced
	* and locked. If any error happens the orinal vnode is unlocked and
	* released.
	*/
	static int
	zfsctl_mounted_here(vnode_t **vpp, int flags)
	{
	struct mount *mp;
	int err;

	ASSERT_VOP_LOCKED(*vpp, __func__);
	ASSERT3S((*vpp)->v_type, ==, VDIR);

	if ((mp = (*vpp)->v_mountedhere) != NULL) {
	err = vfs_busy(mp, 0);
	KASSERT(err == 0, ("vfs_busy(mp, 0) failed with %d", err));
	KASSERT(vrefcnt(*vpp) > 1, ("unreferenced mountpoint"));
	vput(*vpp);
	err = VFS_ROOT(mp, flags, vpp);
	vfs_unbusy(mp);
	return (err);
	}
	return (EJUSTRETURN);
	}

	typedef struct {
	const char *snap_name;
	uint64_t snap_id;
	} snapshot_setup_arg_t;

	static void
	zfsctl_snapshot_vnode_setup(vnode_t vp, void arg)
	{
	snapshot_setup_arg_t *ssa = arg;
	sfs_node_t *node;

	ASSERT_VOP_ELOCKED(vp, __func__);

	node = sfs_alloc_node(sizeof (sfs_node_t),
	ssa->snap_name, ZFSCTL_INO_SNAPDIR, ssa->snap_id);
	zfsctl_common_vnode_setup(vp, node);

	/* We have to support recursive locking. */
	VN_LOCK_AREC(vp);
	}

	/*
	* Lookup entry point for the 'snapshot' directory. Try to open the
	* snapshot if it exist, creating the pseudo filesystem vnode as necessary.
	* Perform a mount of the associated dataset on top of the vnode.
	* There are four possibilities:
	* - the snapshot node and vnode do not exist
	* - the snapshot vnode is covered by the mounted snapshot
	* - the snapshot vnode is not covered yet, the mount operation is in progress
	* - the snapshot vnode is not covered, because the snapshot has been unmounted
	* The last two states are transient and should be relatively short-lived.
	*/
	static int
	zfsctl_snapdir_lookup(struct vop_lookup_args *ap)
	{
	vnode_t *dvp = ap->a_dvp;
	vnode_t **vpp = ap->a_vpp;
	struct componentname *cnp = ap->a_cnp;
	char name[NAME_MAX + 1];
	char fullname[ZFS_MAX_DATASET_NAME_LEN];
	char *mountpoint;
	size_t mountpoint_len;
	zfsvfs_t *zfsvfs = dvp->v_vfsp->vfs_data;
	uint64_t snap_id;
	int nameiop = cnp->cn_nameiop;
	int lkflags = cnp->cn_lkflags;
	int flags = cnp->cn_flags;
	int err;

	ASSERT3S(dvp->v_type, ==, VDIR);

	if ((flags & ISLASTCN) != 0 && nameiop != LOOKUP)
	return (SET_ERROR(ENOTSUP));

	if (cnp->cn_namelen == 1 && *cnp->cn_nameptr == '.') {
	err = zfsctl_relock_dot(dvp, lkflags & LK_TYPE_MASK);
	if (err == 0)
	*vpp = dvp;
	return (err);
	}
	if (flags & ISDOTDOT) {
	err = vn_vget_ino_gen(dvp, zfsctl_root_vnode, NULL, lkflags,
	vpp);
	return (err);
	}

	if (cnp->cn_namelen >= sizeof (name))
	return (SET_ERROR(ENAMETOOLONG));

	strlcpy(name, ap->a_cnp->cn_nameptr, ap->a_cnp->cn_namelen + 1);
	err = zfsctl_snapshot_lookup(dvp, name, &snap_id);
	if (err != 0)
	return (SET_ERROR(ENOENT));

	for (;;) {
	snapshot_setup_arg_t ssa;

	ssa.snap_name = name;
	ssa.snap_id = snap_id;
	err = sfs_vgetx(dvp->v_mount, LK_SHARED, ZFSCTL_INO_SNAPDIR,
	snap_id, "zfs", &zfsctl_ops_snapshot,
	zfsctl_snapshot_vnode_setup, &ssa, vpp);
	if (err != 0)
	return (err);

	/* Check if a new vnode has just been created. */
	if (VOP_ISLOCKED(*vpp) == LK_EXCLUSIVE)
	break;

	/*
	* Check if a snapshot is already mounted on top of the vnode.
	*/
	err = zfsctl_mounted_here(vpp, lkflags);
	if (err != EJUSTRETURN)
	return (err);

	/*
	* If the vnode is not covered, then either the mount operation
	* is in progress or the snapshot has already been unmounted
	* but the vnode hasn't been inactivated and reclaimed yet.
	* We can try to re-use the vnode in the latter case.
	*/
	VI_LOCK(*vpp);
	if (((*vpp)->v_iflag & VI_MOUNT) == 0) {
	/*
	* Upgrade to exclusive lock in order to:
	* - avoid race conditions
	* - satisfy the contract of mount_snapshot()
	*/
	err = VOP_LOCK(*vpp, LK_TRYUPGRADE \| LK_INTERLOCK);
	if (err == 0)
	break;
	} else {
	VI_UNLOCK(*vpp);
	}

	/*
	* In this state we can loop on uncontested locks and starve
	* the thread doing the lengthy, non-trivial mount operation.
	* So, yield to prevent that from happening.
	*/
	vput(*vpp);
	kern_yield(PRI_USER);
	}

	VERIFY0(zfsctl_snapshot_zname(dvp, name, sizeof (fullname), fullname));

	mountpoint_len = strlen(dvp->v_vfsp->mnt_stat.f_mntonname) +
	strlen("/" ZFS_CTLDIR_NAME "/snapshot/") + strlen(name) + 1;
	mountpoint = kmem_alloc(mountpoint_len, KM_SLEEP);
	(void) snprintf(mountpoint, mountpoint_len,
	"%s/" ZFS_CTLDIR_NAME "/snapshot/%s",
	dvp->v_vfsp->mnt_stat.f_mntonname, name);

	err = mount_snapshot(curthread, vpp, "zfs", mountpoint, fullname, 0);
	kmem_free(mountpoint, mountpoint_len);
	if (err == 0) {
	/*
	* Fix up the root vnode mounted on .zfs/snapshot/<snapname>.
	*
	* This is where we lie about our v_vfsp in order to
	* make .zfs/snapshot/<snapname> accessible over NFS
	* without requiring manual mounts of <snapname>.
	*/
	ASSERT3P(VTOZ(*vpp)->z_zfsvfs, !=, zfsvfs);
	VTOZ(*vpp)->z_zfsvfs->z_parent = zfsvfs;

	/* Clear the root flag (set via VFS_ROOT) as well. */
	(*vpp)->v_vflag &= ~VV_ROOT;
	}

	if (err != 0)
	*vpp = NULL;
	return (err);
	}

	static int
	zfsctl_snapdir_readdir(struct vop_readdir_args *ap)
	{
	char snapname[ZFS_MAX_DATASET_NAME_LEN];
	struct dirent entry;
	vnode_t *vp = ap->a_vp;
	zfsvfs_t *zfsvfs = vp->v_vfsp->vfs_data;
	zfs_uio_t uio;
	int *eofp = ap->a_eofflag;
	off_t dots_offset;
	int error;

	zfs_uio_init(&uio, ap->a_uio);

	ASSERT3S(vp->v_type, ==, VDIR);

	error = sfs_readdir_common(ZFSCTL_INO_ROOT, ZFSCTL_INO_SNAPDIR, ap,
	&uio, &dots_offset);
	if (error != 0) {
	if (error == ENAMETOOLONG) /* ran out of destination space */
	error = 0;
	return (error);
	}

	ZFS_ENTER(zfsvfs);
	for (;;) {
	uint64_t cookie;
	uint64_t id;

	cookie = zfs_uio_offset(&uio) - dots_offset;

	dsl_pool_config_enter(dmu_objset_pool(zfsvfs->z_os), FTAG);
	error = dmu_snapshot_list_next(zfsvfs->z_os, sizeof (snapname),
	snapname, &id, &cookie, NULL);
	dsl_pool_config_exit(dmu_objset_pool(zfsvfs->z_os), FTAG);
	if (error != 0) {
	if (error == ENOENT) {
	if (eofp != NULL)
	*eofp = 1;
	error = 0;
	}
	ZFS_EXIT(zfsvfs);
	return (error);
	}

	entry.d_fileno = id;
	entry.d_type = DT_DIR;
	strcpy(entry.d_name, snapname);
	entry.d_namlen = strlen(entry.d_name);
	entry.d_reclen = sizeof (entry);
	error = vfs_read_dirent(ap, &entry, zfs_uio_offset(&uio));
	if (error != 0) {
	if (error == ENAMETOOLONG)
	error = 0;
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(error));
	}
	zfs_uio_setoffset(&uio, cookie + dots_offset);
	}
	/* NOTREACHED */
	}

	static int
	zfsctl_snapdir_getattr(struct vop_getattr_args *ap)
	{
	vnode_t *vp = ap->a_vp;
	vattr_t *vap = ap->a_vap;
	zfsvfs_t *zfsvfs = vp->v_vfsp->vfs_data;
	dsl_dataset_t *ds;
	uint64_t snap_count;
	int err;

	ZFS_ENTER(zfsvfs);
	ds = dmu_objset_ds(zfsvfs->z_os);
	zfsctl_common_getattr(vp, vap);
	vap->va_ctime = dmu_objset_snap_cmtime(zfsvfs->z_os);
	vap->va_mtime = vap->va_ctime;
	vap->va_birthtime = vap->va_ctime;
	if (dsl_dataset_phys(ds)->ds_snapnames_zapobj != 0) {
	err = zap_count(dmu_objset_pool(ds->ds_objset)->dp_meta_objset,
	dsl_dataset_phys(ds)->ds_snapnames_zapobj, &snap_count);
	if (err != 0) {
	ZFS_EXIT(zfsvfs);
	return (err);
	}
	vap->va_nlink += snap_count;
	}
	vap->va_size = vap->va_nlink;

	ZFS_EXIT(zfsvfs);
	return (0);
	}

	static struct vop_vector zfsctl_ops_snapdir = {
	.vop_default = &default_vnodeops,
	#if __FreeBSD_version >= 1300121
	.vop_fplookup_vexec = VOP_EAGAIN,
	#endif
	.vop_open = zfsctl_common_open,
	.vop_close = zfsctl_common_close,
	.vop_getattr = zfsctl_snapdir_getattr,
	.vop_access = zfsctl_common_access,
	.vop_readdir = zfsctl_snapdir_readdir,
	.vop_lookup = zfsctl_snapdir_lookup,
	.vop_reclaim = zfsctl_common_reclaim,
	.vop_fid = zfsctl_common_fid,
	.vop_print = zfsctl_common_print,
	.vop_pathconf = zfsctl_common_pathconf,
	.vop_getacl = zfsctl_common_getacl,
	+#if __FreeBSD_version >= 1400043
	+ .vop_add_writecount = vop_stdadd_writecount_nomsync,
	+#endif
	};
	VFS_VOP_VECTOR_REGISTER(zfsctl_ops_snapdir);


	static int
	zfsctl_snapshot_inactive(struct vop_inactive_args *ap)
	{
	vnode_t *vp = ap->a_vp;

	VERIFY3S(vrecycle(vp), ==, 1);
	return (0);
	}

	static int
	zfsctl_snapshot_reclaim(struct vop_reclaim_args *ap)
	{
	vnode_t *vp = ap->a_vp;
	void *data = vp->v_data;

	sfs_reclaim_vnode(vp);
	sfs_destroy_node(data);
	return (0);
	}

	static int
	zfsctl_snapshot_vptocnp(struct vop_vptocnp_args *ap)
	{
	struct mount *mp;
	vnode_t *dvp;
	vnode_t *vp;
	sfs_node_t *node;
	size_t len;
	int locked;
	int error;

	vp = ap->a_vp;
	node = vp->v_data;
	len = strlen(node->sn_name);
	if (*ap->a_buflen < len)
	return (SET_ERROR(ENOMEM));

	/*
	* Prevent unmounting of the snapshot while the vnode lock
	* is not held. That is not strictly required, but allows
	* us to assert that an uncovered snapshot vnode is never
	* "leaked".
	*/
	mp = vp->v_mountedhere;
	if (mp == NULL)
	return (SET_ERROR(ENOENT));
	error = vfs_busy(mp, 0);
	KASSERT(error == 0, ("vfs_busy(mp, 0) failed with %d", error));

	/*
	* We can vput the vnode as we can now depend on the reference owned
	* by the busied mp. But we also need to hold the vnode, because
	* the reference may go after vfs_unbusy() which has to be called
	* before we can lock the vnode again.
	*/
	locked = VOP_ISLOCKED(vp);
	#if __FreeBSD_version >= 1300045
	enum vgetstate vs = vget_prep(vp);
	#else
	vhold(vp);
	#endif
	vput(vp);

	/* Look up .zfs/snapshot, our parent. */
	error = zfsctl_snapdir_vnode(vp->v_mount, NULL, LK_SHARED, &dvp);
	if (error == 0) {
	VOP_UNLOCK1(dvp);
	*ap->a_vpp = dvp;
	*ap->a_buflen -= len;
	bcopy(node->sn_name, ap->a_buf + *ap->a_buflen, len);
	}
	vfs_unbusy(mp);
	#if __FreeBSD_version >= 1300045
	vget_finish(vp, locked \| LK_RETRY, vs);
	#else
	vget(vp, locked \| LK_VNHELD \| LK_RETRY, curthread);
	#endif
	return (error);
	}

	/*
	* These VP's should never see the light of day. They should always
	* be covered.
	*/
	static struct vop_vector zfsctl_ops_snapshot = {
	.vop_default = NULL, /* ensure very restricted access */
	#if __FreeBSD_version >= 1300121
	.vop_fplookup_vexec = VOP_EAGAIN,
	#endif
	.vop_inactive = zfsctl_snapshot_inactive,
	#if __FreeBSD_version >= 1300045
	.vop_need_inactive = vop_stdneed_inactive,
	#endif
	.vop_reclaim = zfsctl_snapshot_reclaim,
	.vop_vptocnp = zfsctl_snapshot_vptocnp,
	.vop_lock1 = vop_stdlock,
	.vop_unlock = vop_stdunlock,
	.vop_islocked = vop_stdislocked,
	.vop_advlockpurge = vop_stdadvlockpurge, /* called by vgone */
	.vop_print = zfsctl_common_print,
	+#if __FreeBSD_version >= 1400043
	+ .vop_add_writecount = vop_stdadd_writecount_nomsync,
	+#endif
	};
	VFS_VOP_VECTOR_REGISTER(zfsctl_ops_snapshot);

	int
	zfsctl_lookup_objset(vfs_t vfsp, uint64_t objsetid, zfsvfs_t *zfsvfsp)
	{
	zfsvfs_t *zfsvfs __unused = vfsp->vfs_data;
	vnode_t *vp;
	int error;

	ASSERT3P(zfsvfs->z_ctldir, !=, NULL);
	*zfsvfsp = NULL;
	error = sfs_vnode_get(vfsp, LK_EXCLUSIVE,
	ZFSCTL_INO_SNAPDIR, objsetid, &vp);
	if (error == 0 && vp != NULL) {
	/*
	* XXX Probably need to at least reference, if not busy, the mp.
	*/
	if (vp->v_mountedhere != NULL)
	*zfsvfsp = vp->v_mountedhere->mnt_data;
	vput(vp);
	}
	if (*zfsvfsp == NULL)
	return (SET_ERROR(EINVAL));
	return (0);
	}

	/*
	* Unmount any snapshots for the given filesystem. This is called from
	* zfs_umount() - if we have a ctldir, then go through and unmount all the
	* snapshots.
	*/
	int
	zfsctl_umount_snapshots(vfs_t vfsp, int fflags, cred_t cr)
	{
	char snapname[ZFS_MAX_DATASET_NAME_LEN];
	zfsvfs_t *zfsvfs = vfsp->vfs_data;
	struct mount *mp;
	vnode_t *vp;
	uint64_t cookie;
	int error;

	ASSERT3P(zfsvfs->z_ctldir, !=, NULL);

	cookie = 0;
	for (;;) {
	uint64_t id;

	dsl_pool_config_enter(dmu_objset_pool(zfsvfs->z_os), FTAG);
	error = dmu_snapshot_list_next(zfsvfs->z_os, sizeof (snapname),
	snapname, &id, &cookie, NULL);
	dsl_pool_config_exit(dmu_objset_pool(zfsvfs->z_os), FTAG);
	if (error != 0) {
	if (error == ENOENT)
	error = 0;
	break;
	}

	for (;;) {
	error = sfs_vnode_get(vfsp, LK_EXCLUSIVE,
	ZFSCTL_INO_SNAPDIR, id, &vp);
	if (error != 0 \|\| vp == NULL)
	break;

	mp = vp->v_mountedhere;

	/*
	* v_mountedhere being NULL means that the
	* (uncovered) vnode is in a transient state
	* (mounting or unmounting), so loop until it
	* settles down.
	*/
	if (mp != NULL)
	break;
	vput(vp);
	}
	if (error != 0)
	break;
	if (vp == NULL)
	continue; /* no mountpoint, nothing to do */

	/*
	* The mount-point vnode is kept locked to avoid spurious EBUSY
	* from a concurrent umount.
	* The vnode lock must have recursive locking enabled.
	*/
	vfs_ref(mp);
	error = dounmount(mp, fflags, curthread);
	KASSERT_IMPLY(error == 0, vrefcnt(vp) == 1,
	("extra references after unmount"));
	vput(vp);
	if (error != 0)
	break;
	}
	KASSERT_IMPLY((fflags & MS_FORCE) != 0, error == 0,
	("force unmounting failed"));
	return (error);
	}

	int
	zfsctl_snapshot_unmount(const char *snapname, int flags __unused)
	{
	vfs_t *vfsp = NULL;
	zfsvfs_t *zfsvfs = NULL;

	if (strchr(snapname, '@') == NULL)
	return (0);

	int err = getzfsvfs(snapname, &zfsvfs);
	if (err != 0) {
	ASSERT3P(zfsvfs, ==, NULL);
	return (0);
	}
	vfsp = zfsvfs->z_vfs;

	ASSERT(!dsl_pool_config_held(dmu_objset_pool(zfsvfs->z_os)));

	vfs_ref(vfsp);
	vfs_unbusy(vfsp);
	return (dounmount(vfsp, MS_FORCE, curthread));
	}
	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 a3d67aaa11ba..fd86a75416e6 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,299 +1,303 @@
	/*
	* 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;

	+#if __FreeBSD_version < 1400037
	rc = fo_stat(fp, &sb, td->td_ucred, td);
	+#else
	+ rc = fo_stat(fp, &sb, td->td_ucred);
	+#endif
	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));
	}

	zfs_file_t *
	zfs_file_get(int fd)
	{
	struct file *fp;

	if (fget(curthread, fd, &cap_no_rights, &fp))
	return (NULL);

	return (fp);
	}

	void
	zfs_file_put(zfs_file_t *fp)
	{
	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);
	#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
	return (SET_ERROR(rc));
	}
	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 4672b9c2b8b3..8e48f78b7311 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,6162 +1,6189 @@
	/*
	* 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)
	VERIFY0(fs_vscan(vp, cr, 1));

	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;

	ASSERT3P(vp->v_mount, !=, NULL);
	obj = vp->v_object;
	ASSERT3P(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;

	ASSERT3U(zfs_uio_segflg(uio), ==, UIO_NOCOPY);
	ASSERT3P(vp->v_mount, !=, NULL);
	obj = vp->v_object;
	ASSERT3P(obj, !=, NULL);
	ASSERT0(zfs_uio_offset(uio) & PAGEOFFSET);

	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;

	ASSERT3P(vp->v_mount, !=, NULL);
	obj = vp->v_object;
	ASSERT3P(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)
	+ struct componentname cnp, int nameiop, cred_t cr, 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 */
	+ 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;
	+#if __FreeBSD_version < 1400037
	cnp->cn_thread = curthread;
	+#endif

	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);
	+ error = zfs_lookup(ZTOV(dzp), name, vpp, cnp, nameiop, kcred, 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;

	ASSERT3U(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;

	ASSERT3S(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;
	+ objset_t *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);

	+ os = zfsvfs->z_os;
	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);
	ASSERT0(err);
	if (attrzp) {
	vn_seqc_write_begin(ZTOV(attrzp));
	err = zfs_acl_chown_setattr(attrzp);
	vn_seqc_write_end(ZTOV(attrzp));
	ASSERT0(err);
	}
	}

	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;
	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 & 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))
	ASSERT3S(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);
	ASSERT0(err2);
	}

	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);
	}

	+/*
	+ * Look up the directory entries corresponding to the source and target
	+ * directory/name pairs.
	+ */
	+static int
	+zfs_rename_relock_lookup(znode_t sdzp, const struct componentname scnp,
	+ znode_t *szpp, znode_t tdzp, const struct componentname *tcnp,
	+ znode_t **tzpp)
	+{
	+ zfsvfs_t *zfsvfs;
	+ znode_t szp, tzp;
	+ int error;
	+
	+ /*
	+ * 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);
	+ ZFS_VERIFY_ZP(sdzp);
	+ ZFS_VERIFY_ZP(tdzp);
	+
	+ /*
	+ * Re-resolve svp to be certain it still exists and fetch the
	+ * correct vnode.
	+ */
	+ error = zfs_dirent_lookup(sdzp, scnp->cn_nameptr, &szp, ZEXISTS);
	+ if (error != 0) {
	+ /* Source entry invalid or not there. */
	+ if ((scnp->cn_flags & ISDOTDOT) != 0 \|\|
	+ (scnp->cn_namelen == 1 && scnp->cn_nameptr[0] == '.'))
	+ error = SET_ERROR(EINVAL);
	+ goto out;
	+ }
	+ *szpp = szp;
	+
	+ /*
	+ * Re-resolve tvp, if it disappeared we just carry on.
	+ */
	+ error = zfs_dirent_lookup(tdzp, tcnp->cn_nameptr, &tzp, 0);
	+ if (error != 0) {
	+ vrele(ZTOV(szp));
	+ if ((tcnp->cn_flags & ISDOTDOT) != 0)
	+ error = SET_ERROR(EINVAL);
	+ goto out;
	+ }
	+ *tzpp = tzp;
	+out:
	+ ZFS_EXIT(zfsvfs);
	+ return (error);
	+}
	+
	/*
	* 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;
	+ 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);
	+ sdzp = VTOZ(sdvp);

	- /*
	- * 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);
	+ error = zfs_rename_relock_lookup(sdzp, scnp, &szp, tdzp, tcnp, &tzp);
	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);
	+ tvp = tzp != NULL ? ZTOV(tzp) : NULL;

	/*
	* 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

	+static int
	+zfs_do_rename_impl(vnode_t sdvp, vnode_t svpp, struct componentname scnp,
	+ vnode_t tdvp, vnode_t tvpp, struct componentname tcnp,
	+ cred_t *cr);
	+
	/*
	* 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.
	+ * scnp - Old entry name.
	* tdvp - Target directory to contain the "new entry".
	- * tnm - New entry name.
	+ * tcnp - New entry name.
	* cr - credentials of caller.
	- * ct - caller context
	- * flags - case flags
	+ * INOUT: svpp - Source file
	+ * tvpp - Target file, may point to NULL initially
	*
	* 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,
	+zfs_do_rename(vnode_t sdvp, vnode_t svpp, struct componentname scnp,
	vnode_t tdvp, vnode_t tvpp, struct componentname tcnp,
	- cred_t *cr, int log)
	+ cred_t *cr)
	{
	- 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;
	+ int error;
	+
	+ ASSERT_VOP_ELOCKED(tdvp, __func__);
	+ if (*tvpp != NULL)
	+ ASSERT_VOP_ELOCKED(*tvpp, __func__);

	/* 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);
	}

	+ error = zfs_do_rename_impl(sdvp, svpp, scnp, tdvp, tvpp, tcnp, cr);
	+ VOP_UNLOCK1(sdvp);
	+ VOP_UNLOCK1(*svpp);
	+out:
	+ if (*tvpp != NULL)
	+ VOP_UNLOCK1(*tvpp);
	+ if (tdvp != *tvpp)
	+ VOP_UNLOCK1(tdvp);
	+
	+ return (error);
	+}
	+
	+static int
	+zfs_do_rename_impl(vnode_t sdvp, vnode_t svpp, struct componentname scnp,
	+ vnode_t tdvp, vnode_t tvpp, struct componentname tcnp,
	+ cred_t *cr)
	+{
	+ dmu_tx_t *tx;
	+ zfsvfs_t *zfsvfs;
	+ zilog_t *zilog;
	+ znode_t tdzp, sdzp, tzp, szp;
	+ const char *snm = scnp->cn_nameptr;
	+ const char *tnm = tcnp->cn_nameptr;
	+ int 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);
	+ ZFS_VERIFY_ZP(tdzp);
	+ ZFS_VERIFY_ZP(sdzp);
	+ zilog = zfsvfs->z_log;

	if (zfsvfs->z_utf8 && u8_validate(tnm,
	strlen(tnm), NULL, U8_VALIDATE_ENTIRE, &error) < 0) {
	error = SET_ERROR(EILSEQ);
	- goto unlockout;
	+ goto out;
	}

	/* If source and target are the same file, there is nothing to do. */
	if ((svpp) == (tvpp)) {
	error = 0;
	- goto unlockout;
	+ goto out;
	}

	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;
	+ goto out;
	}

	szp = VTOZ(*svpp);
	+ ZFS_VERIFY_ZP(szp);
	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;
	- }
	+ if (tzp != NULL)
	+ ZFS_VERIFY_ZP(tzp);

	/*
	* 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;
	+ goto out;
	}

	/*
	* 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;
	+ 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 unlockout;
	+ goto out;

	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;
	+ goto out;
	}

	/*
	* 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;
	+ goto out;
	}

	/*
	* 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;
	+ goto out;
	} else {
	cache_purge(tdvp);
	if (sdvp != tdvp)
	cache_purge(sdvp);
	}
	} else {
	if ((*tvpp)->v_type == VDIR) {
	error = SET_ERROR(EISDIR);
	- goto unlockout;
	+ goto out;
	}
	}
	}

	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;
	+ goto out_seq;
	}

	-
	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.
	*/
	VERIFY0(zfs_link_destroy(tdzp, tnm, szp, tx,
	ZRENAMING, NULL));
	}
	}
	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_seq:
	+ 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);

	-out: /* original two vnodes are locked */
	- MPASS(!want_seqc_end);
	+out:
	if (error == 0 && zfsvfs->z_os->os_sync == ZFS_SYNC_ALWAYS)
	zil_commit(zilog, 0);
	+ ZFS_EXIT(zfsvfs);

	- 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);
	+ error = zfs_do_rename(sdvp, &svp, &scn, tdvp, &tvp, &tcn, cr);
	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;

	ASSERT3S(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 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;

	ASSERT3S(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));
	+ error = dmu_read_pages(zfsvfs->z_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];

	ASSERT3U(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));
	+ cnp->cn_cred, 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);
	+ error = zfs_do_rename(fdvp, &fvp, ap->a_fcnp, tdvp, &tvp,
	+ ap->a_tcnp, ap->a_fcnp->cn_cred);

	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;
	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;

	ASSERT3P(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 (SET_ERROR(EINVAL));
	/* We don't allow attribute names that start with "freebsd:" string. */
	if (strncmp(name, "freebsd:", 8) == 0)
	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 (SET_ERROR(EINVAL));
	}
	if (snprintf(attrname, size, "%s%s%s%s", prefix, namespace, suffix,
	name) >= size) {
	return (SET_ERROR(ENAMETOOLONG));
	}
	return (0);
	}

	static int
	zfs_ensure_xattr_cached(znode_t *zp)
	{
	int error = 0;

	ASSERT(RW_LOCK_HELD(&zp->z_xattr_lock));

	if (zp->z_xattr_cached != NULL)
	return (0);

	if (rw_write_held(&zp->z_xattr_lock))
	return (zfs_sa_get_xattr(zp));

	if (!rw_tryupgrade(&zp->z_xattr_lock)) {
	rw_exit(&zp->z_xattr_lock);
	rw_enter(&zp->z_xattr_lock, RW_WRITER);
	}
	if (zp->z_xattr_cached == NULL)
	error = zfs_sa_get_xattr(zp);
	rw_downgrade(&zp->z_xattr_lock);
	return (error);
	}

	#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

	static int
	zfs_getextattr_dir(struct vop_getextattr_args ap, const char attrname)
	{
	struct thread *td = ap->a_td;
	struct nameidata nd;
	struct vattr va;
	vnode_t xvp = NULL, vp;
	int error, flags;

	- error = zfs_lookup(ap->a_vp, NULL, &xvp, NULL, 0, ap->a_cred, td,
	+ error = zfs_lookup(ap->a_vp, NULL, &xvp, NULL, 0, ap->a_cred,
	LOOKUP_XATTR, B_FALSE);
	if (error != 0)
	return (error);

	flags = FREAD;
	+#if __FreeBSD_version < 1400043
	NDINIT_ATVP(&nd, LOOKUP, NOFOLLOW, UIO_SYSSPACE, attrname,
	xvp, td);
	+#else
	+ NDINIT_ATVP(&nd, LOOKUP, NOFOLLOW, UIO_SYSSPACE, attrname, xvp);
	+#endif
	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)
	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);
	return (error);
	}

	static int
	zfs_getextattr_sa(struct vop_getextattr_args ap, const char attrname)
	{
	znode_t *zp = VTOZ(ap->a_vp);
	uchar_t *nv_value;
	uint_t nv_size;
	int error;

	error = zfs_ensure_xattr_cached(zp);
	if (error != 0)
	return (error);

	ASSERT(RW_LOCK_HELD(&zp->z_xattr_lock));
	ASSERT3P(zp->z_xattr_cached, !=, NULL);

	error = nvlist_lookup_byte_array(zp->z_xattr_cached, attrname,
	&nv_value, &nv_size);
	if (error)
	return (error);

	if (ap->a_size != NULL)
	*ap->a_size = nv_size;
	else if (ap->a_uio != NULL)
	error = uiomove(nv_value, nv_size, ap->a_uio);

	return (error);
	}

	/*
	* Vnode operation to retrieve a named extended attribute.
	*/
	static int
	zfs_getextattr(struct vop_getextattr_args *ap)
	{
	znode_t *zp = VTOZ(ap->a_vp);
	zfsvfs_t *zfsvfs = ZTOZSB(zp);
	char attrname[EXTATTR_MAXNAMELEN+1];
	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, VREAD);
	if (error != 0)
	return (error);

	error = zfs_create_attrname(ap->a_attrnamespace, ap->a_name, attrname,
	sizeof (attrname));
	if (error != 0)
	return (error);

	error = ENOENT;
	ZFS_ENTER(zfsvfs);
	ZFS_VERIFY_ZP(zp)
	rw_enter(&zp->z_xattr_lock, RW_READER);
	if (zfsvfs->z_use_sa && zp->z_is_sa)
	error = zfs_getextattr_sa(ap, attrname);
	if (error == ENOENT)
	error = zfs_getextattr_dir(ap, attrname);
	rw_exit(&zp->z_xattr_lock);
	ZFS_EXIT(zfsvfs);
	if (error == ENOENT)
	error = SET_ERROR(ENOATTR);
	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

	static int
	zfs_deleteextattr_dir(struct vop_deleteextattr_args ap, const char attrname)
	{
	- struct thread *td = ap->a_td;
	struct nameidata nd;
	vnode_t xvp = NULL, vp;
	int error;

	- error = zfs_lookup(ap->a_vp, NULL, &xvp, NULL, 0, ap->a_cred, td,
	+ error = zfs_lookup(ap->a_vp, NULL, &xvp, NULL, 0, ap->a_cred,
	LOOKUP_XATTR, B_FALSE);
	if (error != 0)
	return (error);

	+#if __FreeBSD_version < 1400043
	+ NDINIT_ATVP(&nd, DELETE, NOFOLLOW \| LOCKPARENT \| LOCKLEAF,
	+ UIO_SYSSPACE, attrname, xvp, ap->a_td);
	+#else
	NDINIT_ATVP(&nd, DELETE, NOFOLLOW \| LOCKPARENT \| LOCKLEAF,
	- UIO_SYSSPACE, attrname, xvp, td);
	+ UIO_SYSSPACE, attrname, xvp);
	+#endif
	error = namei(&nd);
	vp = nd.ni_vp;
	if (error != 0) {
	NDFREE(&nd, NDF_ONLY_PNBUF);
	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);

	return (error);
	}

	static int
	zfs_deleteextattr_sa(struct vop_deleteextattr_args ap, const char attrname)
	{
	znode_t *zp = VTOZ(ap->a_vp);
	nvlist_t *nvl;
	int error;

	error = zfs_ensure_xattr_cached(zp);
	if (error != 0)
	return (error);

	ASSERT(RW_WRITE_HELD(&zp->z_xattr_lock));
	ASSERT3P(zp->z_xattr_cached, !=, NULL);

	nvl = zp->z_xattr_cached;
	error = nvlist_remove(nvl, attrname, DATA_TYPE_BYTE_ARRAY);
	if (error == 0)
	error = zfs_sa_set_xattr(zp);
	if (error != 0) {
	zp->z_xattr_cached = NULL;
	nvlist_free(nvl);
	}
	return (error);
	}

	/*
	* Vnode operation to remove a named attribute.
	*/
	static int
	zfs_deleteextattr(struct vop_deleteextattr_args *ap)
	{
	znode_t *zp = VTOZ(ap->a_vp);
	zfsvfs_t *zfsvfs = ZTOZSB(zp);
	char attrname[EXTATTR_MAXNAMELEN+1];
	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);

	size_t size = 0;
	struct vop_getextattr_args vga = {
	.a_vp = ap->a_vp,
	.a_size = &size,
	.a_cred = ap->a_cred,
	.a_td = ap->a_td,
	};
	error = ENOENT;
	ZFS_ENTER(zfsvfs);
	ZFS_VERIFY_ZP(zp);
	rw_enter(&zp->z_xattr_lock, RW_WRITER);
	if (zfsvfs->z_use_sa && zp->z_is_sa) {
	error = zfs_getextattr_sa(&vga, attrname);
	if (error == 0)
	error = zfs_deleteextattr_sa(ap, attrname);
	}
	if (error == ENOENT) {
	error = zfs_getextattr_dir(&vga, attrname);
	if (error == 0)
	error = zfs_deleteextattr_dir(ap, attrname);
	}
	rw_exit(&zp->z_xattr_lock);
	ZFS_EXIT(zfsvfs);
	if (error == ENOENT)
	error = SET_ERROR(ENOATTR);
	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

	static int
	zfs_setextattr_dir(struct vop_setextattr_args ap, const char attrname)
	{
	struct thread *td = ap->a_td;
	struct nameidata nd;
	struct vattr va;
	vnode_t xvp = NULL, vp;
	int error, flags;

	- error = zfs_lookup(ap->a_vp, NULL, &xvp, NULL, 0, ap->a_cred, td,
	+ error = zfs_lookup(ap->a_vp, NULL, &xvp, NULL, 0, ap->a_cred,
	LOOKUP_XATTR \| CREATE_XATTR_DIR, B_FALSE);
	if (error != 0)
	return (error);

	flags = FFLAGS(O_WRONLY \| O_CREAT);
	+#if __FreeBSD_version < 1400043
	NDINIT_ATVP(&nd, LOOKUP, NOFOLLOW, UIO_SYSSPACE, attrname, xvp, td);
	+#else
	+ NDINIT_ATVP(&nd, LOOKUP, NOFOLLOW, UIO_SYSSPACE, attrname, xvp);
	+#endif
	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)
	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);
	return (error);
	}

	static int
	zfs_setextattr_sa(struct vop_setextattr_args ap, const char attrname)
	{
	znode_t *zp = VTOZ(ap->a_vp);
	nvlist_t *nvl;
	size_t sa_size;
	int error;

	error = zfs_ensure_xattr_cached(zp);
	if (error != 0)
	return (error);

	ASSERT(RW_WRITE_HELD(&zp->z_xattr_lock));
	ASSERT3P(zp->z_xattr_cached, !=, NULL);

	nvl = zp->z_xattr_cached;
	size_t entry_size = ap->a_uio->uio_resid;
	if (entry_size > DXATTR_MAX_ENTRY_SIZE)
	return (SET_ERROR(EFBIG));
	error = nvlist_size(nvl, &sa_size, NV_ENCODE_XDR);
	if (error != 0)
	return (error);
	if (sa_size > DXATTR_MAX_SA_SIZE)
	return (SET_ERROR(EFBIG));
	uchar_t *buf = kmem_alloc(entry_size, KM_SLEEP);
	error = uiomove(buf, entry_size, ap->a_uio);
	if (error == 0)
	error = nvlist_add_byte_array(nvl, attrname, buf, entry_size);
	kmem_free(buf, entry_size);
	if (error == 0)
	error = zfs_sa_set_xattr(zp);
	if (error != 0) {
	zp->z_xattr_cached = NULL;
	nvlist_free(nvl);
	}
	return (error);
	}

	/*
	* Vnode operation to set a named attribute.
	*/
	static int
	zfs_setextattr(struct vop_setextattr_args *ap)
	{
	znode_t *zp = VTOZ(ap->a_vp);
	zfsvfs_t *zfsvfs = ZTOZSB(zp);
	char attrname[EXTATTR_MAXNAMELEN+1];
	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);

	struct vop_deleteextattr_args vda = {
	.a_vp = ap->a_vp,
	.a_cred = ap->a_cred,
	.a_td = ap->a_td,
	};
	error = ENOENT;
	ZFS_ENTER(zfsvfs);
	ZFS_VERIFY_ZP(zp);
	rw_enter(&zp->z_xattr_lock, RW_WRITER);
	if (zfsvfs->z_use_sa && zp->z_is_sa && zfsvfs->z_xattr_sa) {
	error = zfs_setextattr_sa(ap, attrname);
	if (error == 0)
	/*
	* Successfully put into SA, we need to clear the one
	* in dir if present.
	*/
	zfs_deleteextattr_dir(&vda, attrname);
	}
	if (error) {
	error = zfs_setextattr_dir(ap, attrname);
	if (error == 0 && zp->z_is_sa)
	/*
	* Successfully put into dir, we need to clear the one
	* in SA if present.
	*/
	zfs_deleteextattr_sa(&vda, attrname);
	}
	rw_exit(&zp->z_xattr_lock);
	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

	static int
	zfs_listextattr_dir(struct vop_listextattr_args ap, const char attrprefix)
	{
	struct thread *td = ap->a_td;
	struct nameidata nd;
	uint8_t dirbuf[sizeof (struct dirent)];
	struct iovec aiov;
	struct uio auio;
	vnode_t xvp = NULL, vp;
	int error, eof;

	- error = zfs_lookup(ap->a_vp, NULL, &xvp, NULL, 0, ap->a_cred, td,
	+ error = zfs_lookup(ap->a_vp, NULL, &xvp, NULL, 0, ap->a_cred,
	LOOKUP_XATTR, B_FALSE);
	if (error != 0) {
	/*
	* 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);
	}

	+#if __FreeBSD_version < 1400043
	NDINIT_ATVP(&nd, LOOKUP, NOFOLLOW \| LOCKLEAF \| LOCKSHARED,
	UIO_SYSSPACE, ".", xvp, td);
	+#else
	+ NDINIT_ATVP(&nd, LOOKUP, NOFOLLOW \| LOCKLEAF \| LOCKSHARED,
	+ UIO_SYSSPACE, ".", xvp);
	+#endif
	error = namei(&nd);
	vp = nd.ni_vp;
	NDFREE(&nd, NDF_ONLY_PNBUF);
	if (error != 0)
	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;

	size_t plen = strlen(attrprefix);

	do {
	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);
	if (error != 0)
	break;
	int done = sizeof (dirbuf) - auio.uio_resid;
	for (int pos = 0; pos < done; ) {
	struct dirent 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;
	else if (plen == 0 &&
	strncmp(dp->d_name, "freebsd:", 8) == 0)
	continue;
	else if (strncmp(dp->d_name, attrprefix, plen) != 0)
	continue;
	uint8_t nlen = dp->d_namlen - plen;
	if (ap->a_size != NULL) {
	*ap->a_size += 1 + nlen;
	} else if (ap->a_uio != NULL) {
	/*
	* Format of extattr name entry is one byte for
	* length and the rest for name.
	*/
	error = uiomove(&nlen, 1, ap->a_uio);
	if (error == 0) {
	char *namep = dp->d_name + plen;
	error = uiomove(namep, nlen, ap->a_uio);
	}
	if (error != 0)
	break;
	}
	}
	} while (!eof && error == 0);

	vput(vp);
	return (error);
	}

	static int
	zfs_listextattr_sa(struct vop_listextattr_args ap, const char attrprefix)
	{
	znode_t *zp = VTOZ(ap->a_vp);
	int error;

	error = zfs_ensure_xattr_cached(zp);
	if (error != 0)
	return (error);

	ASSERT(RW_LOCK_HELD(&zp->z_xattr_lock));
	ASSERT3P(zp->z_xattr_cached, !=, NULL);

	size_t plen = strlen(attrprefix);
	nvpair_t *nvp = NULL;
	while ((nvp = nvlist_next_nvpair(zp->z_xattr_cached, nvp)) != NULL) {
	ASSERT3U(nvpair_type(nvp), ==, DATA_TYPE_BYTE_ARRAY);

	const char *name = nvpair_name(nvp);
	if (plen == 0 && strncmp(name, "freebsd:", 8) == 0)
	continue;
	else if (strncmp(name, attrprefix, plen) != 0)
	continue;
	uint8_t nlen = strlen(name) - plen;
	if (ap->a_size != NULL) {
	*ap->a_size += 1 + nlen;
	} else if (ap->a_uio != NULL) {
	/*
	* Format of extattr name entry is one byte for
	* length and the rest for name.
	*/
	error = uiomove(&nlen, 1, ap->a_uio);
	if (error == 0) {
	char namep = __DECONST(char , name) + plen;
	error = uiomove(namep, nlen, ap->a_uio);
	}
	if (error != 0)
	break;
	}
	}

	return (error);
	}

	/*
	* Vnode operation to retrieve extended attributes on a vnode.
	*/
	static int
	zfs_listextattr(struct vop_listextattr_args *ap)
	{
	znode_t *zp = VTOZ(ap->a_vp);
	zfsvfs_t *zfsvfs = ZTOZSB(zp);
	char attrprefix[16];
	int error;

	if (ap->a_size != NULL)
	*ap->a_size = 0;

	/*
	* 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);

	ZFS_ENTER(zfsvfs);
	ZFS_VERIFY_ZP(zp);
	rw_enter(&zp->z_xattr_lock, RW_READER);
	if (zfsvfs->z_use_sa && zp->z_is_sa)
	error = zfs_listextattr_sa(ap, attrprefix);
	if (error == 0)
	error = zfs_listextattr_dir(ap, attrprefix);
	rw_exit(&zp->z_xattr_lock);
	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
	+#if __FreeBSD_version >= 1400043
	+ .vop_add_writecount = vop_stdadd_writecount_nomsync,
	+#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,
	+#if __FreeBSD_version >= 1400043
	+ .vop_add_writecount = vop_stdadd_writecount_nomsync,
	+#endif
	};
	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,
	+#if __FreeBSD_version >= 1400043
	+ .vop_add_writecount = vop_stdadd_writecount_nomsync,
	+#endif
	};
	VFS_VOP_VECTOR_REGISTER(zfs_shareops);
	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 91eeaccfdc47..5ea4fc635165 100644
	--- a/sys/contrib/openzfs/module/os/linux/spl/spl-generic.c
	+++ b/sys/contrib/openzfs/module/os/linux/spl/spl-generic.c
	@@ -1,843 +1,844 @@
	/*
	* 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);
	#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;
	+ // cppcheck-suppress sizeofwithnumericparameter
	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/zfs/vdev_disk.c b/sys/contrib/openzfs/module/os/linux/zfs/vdev_disk.c
	index c56fd3a6ff21..a432a736453c 100644
	--- a/sys/contrib/openzfs/module/os/linux/zfs/vdev_disk.c
	+++ b/sys/contrib/openzfs/module/os/linux/zfs/vdev_disk.c
	@@ -1,928 +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) 2008-2010 Lawrence Livermore National Security, LLC.
	* Produced at Lawrence Livermore National Laboratory (cf, DISCLAIMER).
	* Rewritten for Linux by Brian Behlendorf <behlendorf1@llnl.gov>.
	* LLNL-CODE-403049.
	* Copyright (c) 2012, 2019 by Delphix. All rights reserved.
	*/

	#include <sys/zfs_context.h>
	#include <sys/spa_impl.h>
	#include <sys/vdev_disk.h>
	#include <sys/vdev_impl.h>
	#include <sys/vdev_trim.h>
	#include <sys/abd.h>
	#include <sys/fs/zfs.h>
	#include <sys/zio.h>
	#include <linux/blkpg.h>
	#include <linux/msdos_fs.h>
	#include <linux/vfs_compat.h>
	+#ifdef HAVE_LINUX_BLK_CGROUP_HEADER
	+#include <linux/blk-cgroup.h>
	+#endif

	typedef struct vdev_disk {
	struct block_device *vd_bdev;
	krwlock_t vd_lock;
	} vdev_disk_t;

	/*
	* Unique identifier for the exclusive vdev holder.
	*/
	static void *zfs_vdev_holder = VDEV_HOLDER;

	/*
	* Wait up to zfs_vdev_open_timeout_ms milliseconds before determining the
	* device is missing. The missing path may be transient since the links
	* can be briefly removed and recreated in response to udev events.
	*/
	static unsigned zfs_vdev_open_timeout_ms = 1000;

	/*
	* Size of the "reserved" partition, in blocks.
	*/
	#define EFI_MIN_RESV_SIZE (16 * 1024)

	/*
	* Virtual device vector for disks.
	*/
	typedef struct dio_request {
	zio_t dr_zio; / Parent ZIO */
	atomic_t dr_ref; /* References */
	int dr_error; /* Bio error */
	int dr_bio_count; /* Count of bio's */
	struct bio dr_bio[0]; / Attached bio's */
	} dio_request_t;

	static fmode_t
	vdev_bdev_mode(spa_mode_t spa_mode)
	{
	fmode_t mode = 0;

	if (spa_mode & SPA_MODE_READ)
	mode \|= FMODE_READ;

	if (spa_mode & SPA_MODE_WRITE)
	mode \|= FMODE_WRITE;

	return (mode);
	}

	/*
	* Returns the usable capacity (in bytes) for the partition or disk.
	*/
	static uint64_t
	bdev_capacity(struct block_device *bdev)
	{
	return (i_size_read(bdev->bd_inode));
	}

	#if !defined(HAVE_BDEV_WHOLE)
	static inline struct block_device *
	bdev_whole(struct block_device *bdev)
	{
	return (bdev->bd_contains);
	}
	#endif

	/*
	* Returns the maximum expansion capacity of the block device (in bytes).
	*
	* It is possible to expand a vdev when it has been created as a wholedisk
	* and the containing block device has increased in capacity. Or when the
	* partition containing the pool has been manually increased in size.
	*
	* This function is only responsible for calculating the potential expansion
	* size so it can be reported by 'zpool list'. The efi_use_whole_disk() is
	* responsible for verifying the expected partition layout in the wholedisk
	* case, and updating the partition table if appropriate. Once the partition
	* size has been increased the additional capacity will be visible using
	* bdev_capacity().
	*
	* The returned maximum expansion capacity is always expected to be larger, or
	* at the very least equal, to its usable capacity to prevent overestimating
	* the pool expandsize.
	*/
	static uint64_t
	bdev_max_capacity(struct block_device *bdev, uint64_t wholedisk)
	{
	uint64_t psize;
	int64_t available;

	if (wholedisk && bdev != bdev_whole(bdev)) {
	/*
	* When reporting maximum expansion capacity for a wholedisk
	* deduct any capacity which is expected to be lost due to
	* alignment restrictions. Over reporting this value isn't
	* harmful and would only result in slightly less capacity
	* than expected post expansion.
	* The estimated available space may be slightly smaller than
	* bdev_capacity() for devices where the number of sectors is
	* not a multiple of the alignment size and the partition layout
	* is keeping less than PARTITION_END_ALIGNMENT bytes after the
	* "reserved" EFI partition: in such cases return the device
	* usable capacity.
	*/
	available = i_size_read(bdev_whole(bdev)->bd_inode) -
	((EFI_MIN_RESV_SIZE + NEW_START_BLOCK +
	PARTITION_END_ALIGNMENT) << SECTOR_BITS);
	psize = MAX(available, bdev_capacity(bdev));
	} else {
	psize = bdev_capacity(bdev);
	}

	return (psize);
	}

	static void
	vdev_disk_error(zio_t *zio)
	{
	/*
	* This function can be called in interrupt context, for instance while
	* handling IRQs coming from a misbehaving disk device; use printk()
	* which is safe from any context.
	*/
	printk(KERN_WARNING "zio pool=%s vdev=%s error=%d type=%d "
	"offset=%llu size=%llu flags=%x\n", spa_name(zio->io_spa),
	zio->io_vd->vdev_path, zio->io_error, zio->io_type,
	(u_longlong_t)zio->io_offset, (u_longlong_t)zio->io_size,
	zio->io_flags);
	}

	static int
	vdev_disk_open(vdev_t v, uint64_t psize, uint64_t *max_psize,
	uint64_t logical_ashift, uint64_t physical_ashift)
	{
	struct block_device *bdev;
	fmode_t mode = vdev_bdev_mode(spa_mode(v->vdev_spa));
	hrtime_t timeout = MSEC2NSEC(zfs_vdev_open_timeout_ms);
	vdev_disk_t *vd;

	/* Must have a pathname and it must be absolute. */
	if (v->vdev_path == NULL \|\| v->vdev_path[0] != '/') {
	v->vdev_stat.vs_aux = VDEV_AUX_BAD_LABEL;
	vdev_dbgmsg(v, "invalid vdev_path");
	return (SET_ERROR(EINVAL));
	}

	/*
	* Reopen the device if it is currently open. When expanding a
	* partition force re-scanning the partition table if userland
	* did not take care of this already. We need to do this while closed
	* in order to get an accurate updated block device size. Then
	* since udev may need to recreate the device links increase the
	* open retry timeout before reporting the device as unavailable.
	*/
	vd = v->vdev_tsd;
	if (vd) {
	char disk_name[BDEVNAME_SIZE + 6] = "/dev/";
	boolean_t reread_part = B_FALSE;

	rw_enter(&vd->vd_lock, RW_WRITER);
	bdev = vd->vd_bdev;
	vd->vd_bdev = NULL;

	if (bdev) {
	if (v->vdev_expanding && bdev != bdev_whole(bdev)) {
	bdevname(bdev_whole(bdev), disk_name + 5);
	/*
	* If userland has BLKPG_RESIZE_PARTITION,
	* then it should have updated the partition
	* table already. We can detect this by
	* comparing our current physical size
	* with that of the device. If they are
	* the same, then we must not have
	* BLKPG_RESIZE_PARTITION or it failed to
	* update the partition table online. We
	* fallback to rescanning the partition
	* table from the kernel below. However,
	* if the capacity already reflects the
	* updated partition, then we skip
	* rescanning the partition table here.
	*/
	if (v->vdev_psize == bdev_capacity(bdev))
	reread_part = B_TRUE;
	}

	blkdev_put(bdev, mode \| FMODE_EXCL);
	}

	if (reread_part) {
	bdev = blkdev_get_by_path(disk_name, mode \| FMODE_EXCL,
	zfs_vdev_holder);
	if (!IS_ERR(bdev)) {
	int error = vdev_bdev_reread_part(bdev);
	blkdev_put(bdev, mode \| FMODE_EXCL);
	if (error == 0) {
	timeout = MSEC2NSEC(
	zfs_vdev_open_timeout_ms * 2);
	}
	}
	}
	} else {
	vd = kmem_zalloc(sizeof (vdev_disk_t), KM_SLEEP);

	rw_init(&vd->vd_lock, NULL, RW_DEFAULT, NULL);
	rw_enter(&vd->vd_lock, RW_WRITER);
	}

	/*
	* Devices are always opened by the path provided at configuration
	* time. This means that if the provided path is a udev by-id path
	* then drives may be re-cabled without an issue. If the provided
	* path is a udev by-path path, then the physical location information
	* will be preserved. This can be critical for more complicated
	* configurations where drives are located in specific physical
	* locations to maximize the systems tolerance to component failure.
	*
	* Alternatively, you can provide your own udev rule to flexibly map
	* the drives as you see fit. It is not advised that you use the
	* /dev/[hd]d devices which may be reordered due to probing order.
	* Devices in the wrong locations will be detected by the higher
	* level vdev validation.
	*
	* The specified paths may be briefly removed and recreated in
	* response to udev events. This should be exceptionally unlikely
	* because the zpool command makes every effort to verify these paths
	* have already settled prior to reaching this point. Therefore,
	* a ENOENT failure at this point is highly likely to be transient
	* and it is reasonable to sleep and retry before giving up. In
	* practice delays have been observed to be on the order of 100ms.
	+ *
	+ * When ERESTARTSYS is returned it indicates the block device is
	+ * a zvol which could not be opened due to the deadlock detection
	+ * logic in zvol_open(). Extend the timeout and retry the open
	+ * subsequent attempts are expected to eventually succeed.
	*/
	hrtime_t start = gethrtime();
	bdev = ERR_PTR(-ENXIO);
	while (IS_ERR(bdev) && ((gethrtime() - start) < timeout)) {
	bdev = blkdev_get_by_path(v->vdev_path, mode \| FMODE_EXCL,
	zfs_vdev_holder);
	if (unlikely(PTR_ERR(bdev) == -ENOENT)) {
	schedule_timeout(MSEC_TO_TICK(10));
	+ } else if (unlikely(PTR_ERR(bdev) == -ERESTARTSYS)) {
	+ timeout = MSEC2NSEC(zfs_vdev_open_timeout_ms * 10);
	+ continue;
	} else if (IS_ERR(bdev)) {
	break;
	}
	}

	if (IS_ERR(bdev)) {
	int error = -PTR_ERR(bdev);
	vdev_dbgmsg(v, "open error=%d timeout=%llu/%llu", error,
	(u_longlong_t)(gethrtime() - start),
	(u_longlong_t)timeout);
	vd->vd_bdev = NULL;
	v->vdev_tsd = vd;
	rw_exit(&vd->vd_lock);
	return (SET_ERROR(error));
	} else {
	vd->vd_bdev = bdev;
	v->vdev_tsd = vd;
	rw_exit(&vd->vd_lock);
	}

	struct request_queue *q = bdev_get_queue(vd->vd_bdev);

	/* Determine the physical block size */
	int physical_block_size = bdev_physical_block_size(vd->vd_bdev);

	/* Determine the logical block size */
	int logical_block_size = bdev_logical_block_size(vd->vd_bdev);

	/* Clear the nowritecache bit, causes vdev_reopen() to try again. */
	v->vdev_nowritecache = B_FALSE;

	/* Set when device reports it supports TRIM. */
	v->vdev_has_trim = !!blk_queue_discard(q);

	/* Set when device reports it supports secure TRIM. */
	v->vdev_has_securetrim = !!blk_queue_discard_secure(q);

	/* Inform the ZIO pipeline that we are non-rotational */
	v->vdev_nonrot = blk_queue_nonrot(q);

	/* Physical volume size in bytes for the partition */
	*psize = bdev_capacity(vd->vd_bdev);

	/* Physical volume size in bytes including possible expansion space */
	*max_psize = bdev_max_capacity(vd->vd_bdev, v->vdev_wholedisk);

	/* Based on the minimum sector size set the block size */
	*physical_ashift = highbit64(MAX(physical_block_size,
	SPA_MINBLOCKSIZE)) - 1;

	*logical_ashift = highbit64(MAX(logical_block_size,
	SPA_MINBLOCKSIZE)) - 1;

	return (0);
	}

	static void
	vdev_disk_close(vdev_t *v)
	{
	vdev_disk_t *vd = v->vdev_tsd;

	if (v->vdev_reopening \|\| vd == NULL)
	return;

	if (vd->vd_bdev != NULL) {
	blkdev_put(vd->vd_bdev,
	vdev_bdev_mode(spa_mode(v->vdev_spa)) \| FMODE_EXCL);
	}

	rw_destroy(&vd->vd_lock);
	kmem_free(vd, sizeof (vdev_disk_t));
	v->vdev_tsd = NULL;
	}

	static dio_request_t *
	vdev_disk_dio_alloc(int bio_count)
	{
	dio_request_t *dr = kmem_zalloc(sizeof (dio_request_t) +
	sizeof (struct bio ) bio_count, KM_SLEEP);
	atomic_set(&dr->dr_ref, 0);
	dr->dr_bio_count = bio_count;
	dr->dr_error = 0;

	for (int i = 0; i < dr->dr_bio_count; i++)
	dr->dr_bio[i] = NULL;

	return (dr);
	}

	static void
	vdev_disk_dio_free(dio_request_t *dr)
	{
	int i;

	for (i = 0; i < dr->dr_bio_count; i++)
	if (dr->dr_bio[i])
	bio_put(dr->dr_bio[i]);

	kmem_free(dr, sizeof (dio_request_t) +
	sizeof (struct bio ) dr->dr_bio_count);
	}

	static void
	vdev_disk_dio_get(dio_request_t *dr)
	{
	atomic_inc(&dr->dr_ref);
	}

	static int
	vdev_disk_dio_put(dio_request_t *dr)
	{
	int rc = atomic_dec_return(&dr->dr_ref);

	/*
	* Free the dio_request when the last reference is dropped and
	* ensure zio_interpret is called only once with the correct zio
	*/
	if (rc == 0) {
	zio_t *zio = dr->dr_zio;
	int error = dr->dr_error;

	vdev_disk_dio_free(dr);

	if (zio) {
	zio->io_error = error;
	ASSERT3S(zio->io_error, >=, 0);
	if (zio->io_error)
	vdev_disk_error(zio);

	zio_delay_interrupt(zio);
	}
	}

	return (rc);
	}

	BIO_END_IO_PROTO(vdev_disk_physio_completion, bio, error)
	{
	dio_request_t *dr = bio->bi_private;
	int rc;

	if (dr->dr_error == 0) {
	#ifdef HAVE_1ARG_BIO_END_IO_T
	dr->dr_error = BIO_END_IO_ERROR(bio);
	#else
	if (error)
	dr->dr_error = -(error);
	else if (!test_bit(BIO_UPTODATE, &bio->bi_flags))
	dr->dr_error = EIO;
	#endif
	}

	/* Drop reference acquired by __vdev_disk_physio */
	rc = vdev_disk_dio_put(dr);
	}

	static inline void
	vdev_submit_bio_impl(struct bio *bio)
	{
	#ifdef HAVE_1ARG_SUBMIT_BIO
	- submit_bio(bio);
	+ (void) submit_bio(bio);
	#else
	- submit_bio(0, bio);
	+ (void) submit_bio(0, bio);
	#endif
	}

	/*
	* preempt_schedule_notrace is GPL-only which breaks the ZFS build, so
	* replace it with preempt_schedule under the following condition:
	*/
	#if defined(CONFIG_ARM64) && \
	defined(CONFIG_PREEMPTION) && \
	defined(CONFIG_BLK_CGROUP)
	#define preempt_schedule_notrace(x) preempt_schedule(x)
	#endif

	#ifdef HAVE_BIO_SET_DEV
	#if defined(CONFIG_BLK_CGROUP) && defined(HAVE_BIO_SET_DEV_GPL_ONLY)
	/*
	* The Linux 5.5 kernel updated percpu_ref_tryget() which is inlined by
	* blkg_tryget() to use rcu_read_lock() instead of rcu_read_lock_sched().
	* As a side effect the function was converted to GPL-only. Define our
	* own version when needed which uses rcu_read_lock_sched().
	*/
	#if defined(HAVE_BLKG_TRYGET_GPL_ONLY)
	static inline bool
	vdev_blkg_tryget(struct blkcg_gq *blkg)
	{
	struct percpu_ref *ref = &blkg->refcnt;
	unsigned long __percpu *count;
	bool rc;

	rcu_read_lock_sched();

	if (__ref_is_percpu(ref, &count)) {
	this_cpu_inc(*count);
	rc = true;
	} else {
	#ifdef ZFS_PERCPU_REF_COUNT_IN_DATA
	rc = atomic_long_inc_not_zero(&ref->data->count);
	#else
	rc = atomic_long_inc_not_zero(&ref->count);
	#endif
	}

	rcu_read_unlock_sched();

	return (rc);
	}
	#elif defined(HAVE_BLKG_TRYGET)
	#define vdev_blkg_tryget(bg) blkg_tryget(bg)
	#endif
	+#ifdef HAVE_BIO_SET_DEV_MACRO
	/*
	* The Linux 5.0 kernel updated the bio_set_dev() macro so it calls the
	* GPL-only bio_associate_blkg() symbol thus inadvertently converting
	* the entire macro. Provide a minimal version which always assigns the
	* request queue's root_blkg to the bio.
	*/
	static inline void
	vdev_bio_associate_blkg(struct bio *bio)
	{
	#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

	ASSERT3P(q, !=, NULL);
	ASSERT3P(bio->bi_blkg, ==, NULL);

	if (q->root_blkg && vdev_blkg_tryget(q->root_blkg))
	bio->bi_blkg = q->root_blkg;
	}
	+
	#define bio_associate_blkg vdev_bio_associate_blkg
	+#else
	+static inline void
	+vdev_bio_set_dev(struct bio bio, struct block_device bdev)
	+{
	+#if defined(HAVE_BIO_BDEV_DISK)
	+ struct request_queue *q = bdev->bd_disk->queue;
	+#else
	+ struct request_queue *q = bio->bi_disk->queue;
	+#endif
	+ bio_clear_flag(bio, BIO_REMAPPED);
	+ if (bio->bi_bdev != bdev)
	+ bio_clear_flag(bio, BIO_THROTTLED);
	+ bio->bi_bdev = bdev;
	+
	+ ASSERT3P(q, !=, NULL);
	+ ASSERT3P(bio->bi_blkg, ==, NULL);
	+
	+ if (q->root_blkg && vdev_blkg_tryget(q->root_blkg))
	+ bio->bi_blkg = q->root_blkg;
	+}
	+#define bio_set_dev vdev_bio_set_dev
	+#endif
	#endif
	#else
	/*
	* Provide a bio_set_dev() helper macro for pre-Linux 4.14 kernels.
	*/
	static inline void
	bio_set_dev(struct bio bio, struct block_device bdev)
	{
	bio->bi_bdev = bdev;
	}
	#endif /* HAVE_BIO_SET_DEV */

	static inline void
	vdev_submit_bio(struct bio *bio)
	{
	struct bio_list *bio_list = current->bio_list;
	current->bio_list = NULL;
	vdev_submit_bio_impl(bio);
	current->bio_list = bio_list;
	}

	static int
	__vdev_disk_physio(struct block_device bdev, zio_t zio,
	size_t io_size, uint64_t io_offset, int rw, int flags)
	{
	dio_request_t *dr;
	uint64_t abd_offset;
	uint64_t bio_offset;
	int bio_size;
	int bio_count = 16;
	int error = 0;
	struct blk_plug plug;

	/*
	* Accessing outside the block device is never allowed.
	*/
	if (io_offset + io_size > bdev->bd_inode->i_size) {
	vdev_dbgmsg(zio->io_vd,
	"Illegal access %llu size %llu, device size %llu",
	io_offset, io_size, i_size_read(bdev->bd_inode));
	return (SET_ERROR(EIO));
	}

	retry:
	dr = vdev_disk_dio_alloc(bio_count);

	if (zio && !(zio->io_flags & (ZIO_FLAG_IO_RETRY \| ZIO_FLAG_TRYHARD)))
	bio_set_flags_failfast(bdev, &flags);

	dr->dr_zio = zio;

	/*
	* Since bio's can have up to BIO_MAX_PAGES=256 iovec's, each of which
	* is at least 512 bytes and at most PAGESIZE (typically 4K), one bio
	* can cover at least 128KB and at most 1MB. When the required number
	* of iovec's exceeds this, we are forced to break the IO in multiple
	* bio's and wait for them all to complete. This is likely if the
	* recordsize property is increased beyond 1MB. The default
	* bio_count=16 should typically accommodate the maximum-size zio of
	* 16MB.
	*/

	abd_offset = 0;
	bio_offset = io_offset;
	bio_size = io_size;
	for (int i = 0; i <= dr->dr_bio_count; i++) {

	/* Finished constructing bio's for given buffer */
	if (bio_size <= 0)
	break;

	/*
	* If additional bio's are required, we have to retry, but
	* this should be rare - see the comment above.
	*/
	if (dr->dr_bio_count == i) {
	vdev_disk_dio_free(dr);
	bio_count *= 2;
	goto retry;
	}

	/* bio_alloc() with __GFP_WAIT never returns NULL */
	#ifdef HAVE_BIO_MAX_SEGS
	dr->dr_bio[i] = bio_alloc(GFP_NOIO, bio_max_segs(
	abd_nr_pages_off(zio->io_abd, bio_size, abd_offset)));
	#else
	dr->dr_bio[i] = bio_alloc(GFP_NOIO,
	MIN(abd_nr_pages_off(zio->io_abd, bio_size, abd_offset),
	BIO_MAX_PAGES));
	#endif
	if (unlikely(dr->dr_bio[i] == NULL)) {
	vdev_disk_dio_free(dr);
	return (SET_ERROR(ENOMEM));
	}

	/* Matching put called by vdev_disk_physio_completion */
	vdev_disk_dio_get(dr);

	bio_set_dev(dr->dr_bio[i], bdev);
	BIO_BI_SECTOR(dr->dr_bio[i]) = bio_offset >> 9;
	dr->dr_bio[i]->bi_end_io = vdev_disk_physio_completion;
	dr->dr_bio[i]->bi_private = dr;
	bio_set_op_attrs(dr->dr_bio[i], rw, flags);

	/* Remaining size is returned to become the new size */
	bio_size = abd_bio_map_off(dr->dr_bio[i], zio->io_abd,
	bio_size, abd_offset);

	/* Advance in buffer and construct another bio if needed */
	abd_offset += BIO_BI_SIZE(dr->dr_bio[i]);
	bio_offset += BIO_BI_SIZE(dr->dr_bio[i]);
	}

	/* Extra reference to protect dio_request during vdev_submit_bio */
	vdev_disk_dio_get(dr);

	if (dr->dr_bio_count > 1)
	blk_start_plug(&plug);

	/* Submit all bio's associated with this dio */
	for (int i = 0; i < dr->dr_bio_count; i++) {
	if (dr->dr_bio[i])
	vdev_submit_bio(dr->dr_bio[i]);
	}

	if (dr->dr_bio_count > 1)
	blk_finish_plug(&plug);

	(void) vdev_disk_dio_put(dr);

	return (error);
	}

	BIO_END_IO_PROTO(vdev_disk_io_flush_completion, bio, error)
	{
	zio_t *zio = bio->bi_private;
	#ifdef HAVE_1ARG_BIO_END_IO_T
	zio->io_error = BIO_END_IO_ERROR(bio);
	#else
	zio->io_error = -error;
	#endif

	if (zio->io_error && (zio->io_error == EOPNOTSUPP))
	zio->io_vd->vdev_nowritecache = B_TRUE;

	bio_put(bio);
	ASSERT3S(zio->io_error, >=, 0);
	if (zio->io_error)
	vdev_disk_error(zio);
	zio_interrupt(zio);
	}

	static int
	vdev_disk_io_flush(struct block_device bdev, zio_t zio)
	{
	struct request_queue *q;
	struct bio *bio;

	q = bdev_get_queue(bdev);
	if (!q)
	return (SET_ERROR(ENXIO));

	bio = bio_alloc(GFP_NOIO, 0);
	/* bio_alloc() with __GFP_WAIT never returns NULL */
	if (unlikely(bio == NULL))
	return (SET_ERROR(ENOMEM));

	bio->bi_end_io = vdev_disk_io_flush_completion;
	bio->bi_private = zio;
	bio_set_dev(bio, bdev);
	bio_set_flush(bio);
	vdev_submit_bio(bio);
	invalidate_bdev(bdev);

	return (0);
	}

	static void
	vdev_disk_io_start(zio_t *zio)
	{
	vdev_t *v = zio->io_vd;
	vdev_disk_t *vd = v->vdev_tsd;
	unsigned long trim_flags = 0;
	int rw, error;

	/*
	* If the vdev is closed, it's likely in the REMOVED or FAULTED state.
	* Nothing to be done here but return failure.
	*/
	if (vd == NULL) {
	zio->io_error = ENXIO;
	zio_interrupt(zio);
	return;
	}

	rw_enter(&vd->vd_lock, RW_READER);

	/*
	* If the vdev is closed, it's likely due to a failed reopen and is
	* in the UNAVAIL state. Nothing to be done here but return failure.
	*/
	if (vd->vd_bdev == NULL) {
	rw_exit(&vd->vd_lock);
	zio->io_error = ENXIO;
	zio_interrupt(zio);
	return;
	}

	switch (zio->io_type) {
	case ZIO_TYPE_IOCTL:

	if (!vdev_readable(v)) {
	rw_exit(&vd->vd_lock);
	zio->io_error = SET_ERROR(ENXIO);
	zio_interrupt(zio);
	return;
	}

	switch (zio->io_cmd) {
	case DKIOCFLUSHWRITECACHE:

	if (zfs_nocacheflush)
	break;

	if (v->vdev_nowritecache) {
	zio->io_error = SET_ERROR(ENOTSUP);
	break;
	}

	error = vdev_disk_io_flush(vd->vd_bdev, zio);
	if (error == 0) {
	rw_exit(&vd->vd_lock);
	return;
	}

	zio->io_error = error;

	break;

	default:
	zio->io_error = SET_ERROR(ENOTSUP);
	}

	rw_exit(&vd->vd_lock);
	zio_execute(zio);
	return;
	case ZIO_TYPE_WRITE:
	rw = WRITE;
	break;

	case ZIO_TYPE_READ:
	rw = READ;
	break;

	case ZIO_TYPE_TRIM:
	#if defined(BLKDEV_DISCARD_SECURE)
	if (zio->io_trim_flags & ZIO_TRIM_SECURE)
	trim_flags \|= BLKDEV_DISCARD_SECURE;
	#endif
	zio->io_error = -blkdev_issue_discard(vd->vd_bdev,
	zio->io_offset >> 9, zio->io_size >> 9, GFP_NOFS,
	trim_flags);

	rw_exit(&vd->vd_lock);
	zio_interrupt(zio);
	return;

	default:
	rw_exit(&vd->vd_lock);
	zio->io_error = SET_ERROR(ENOTSUP);
	zio_interrupt(zio);
	return;
	}

	zio->io_target_timestamp = zio_handle_io_delay(zio);
	error = __vdev_disk_physio(vd->vd_bdev, zio,
	zio->io_size, zio->io_offset, rw, 0);
	rw_exit(&vd->vd_lock);

	if (error) {
	zio->io_error = error;
	zio_interrupt(zio);
	return;
	}
	}

	static void
	vdev_disk_io_done(zio_t *zio)
	{
	/*
	* If the device returned EIO, we revalidate the media. If it is
	* determined the media has changed this triggers the asynchronous
	* removal of the device from the configuration.
	*/
	if (zio->io_error == EIO) {
	vdev_t *v = zio->io_vd;
	vdev_disk_t *vd = v->vdev_tsd;

	if (zfs_check_media_change(vd->vd_bdev)) {
	invalidate_bdev(vd->vd_bdev);
	v->vdev_remove_wanted = B_TRUE;
	spa_async_request(zio->io_spa, SPA_ASYNC_REMOVE);
	}
	}
	}

	static void
	vdev_disk_hold(vdev_t *vd)
	{
	ASSERT(spa_config_held(vd->vdev_spa, SCL_STATE, RW_WRITER));

	/* We must have a pathname, and it must be absolute. */
	if (vd->vdev_path == NULL \|\| vd->vdev_path[0] != '/')
	return;

	/*
	* Only prefetch path and devid info if the device has
	* never been opened.
	*/
	if (vd->vdev_tsd != NULL)
	return;

	}

	static void
	vdev_disk_rele(vdev_t *vd)
	{
	ASSERT(spa_config_held(vd->vdev_spa, SCL_STATE, RW_WRITER));

	/* XXX: Implement me as a vnode rele for the device */
	}

	vdev_ops_t vdev_disk_ops = {
	.vdev_op_init = NULL,
	.vdev_op_fini = NULL,
	.vdev_op_open = vdev_disk_open,
	.vdev_op_close = vdev_disk_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_disk_io_start,
	.vdev_op_io_done = vdev_disk_io_done,
	.vdev_op_state_change = NULL,
	.vdev_op_need_resilver = NULL,
	.vdev_op_hold = vdev_disk_hold,
	.vdev_op_rele = vdev_disk_rele,
	.vdev_op_remap = NULL,
	.vdev_op_xlate = vdev_default_xlate,
	.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_DISK, /* name of this vdev type */
	.vdev_op_leaf = B_TRUE /* leaf vdev */
	};

	/*
	* The zfs_vdev_scheduler module option has been deprecated. Setting this
	* value no longer has any effect. It has not yet been entirely removed
	* to allow the module to be loaded if this option is specified in the
	* /etc/modprobe.d/zfs.conf file. The following warning will be logged.
	*/
	static int
	param_set_vdev_scheduler(const char val, zfs_kernel_param_t kp)
	{
	int error = param_set_charp(val, kp);
	if (error == 0) {
	printk(KERN_INFO "The 'zfs_vdev_scheduler' module option "
	"is not supported.\n");
	}

	return (error);
	}

	char *zfs_vdev_scheduler = "unused";
	module_param_call(zfs_vdev_scheduler, param_set_vdev_scheduler,
	param_get_charp, &zfs_vdev_scheduler, 0644);
	MODULE_PARM_DESC(zfs_vdev_scheduler, "I/O scheduler");

	int
	param_set_min_auto_ashift(const char buf, zfs_kernel_param_t kp)
	{
	uint64_t val;
	int error;

	error = kstrtoull(buf, 0, &val);
	if (error < 0)
	return (SET_ERROR(error));

	if (val < ASHIFT_MIN \|\| val > zfs_vdev_max_auto_ashift)
	return (SET_ERROR(-EINVAL));

	error = param_set_ulong(buf, kp);
	if (error < 0)
	return (SET_ERROR(error));

	return (0);
	}

	int
	param_set_max_auto_ashift(const char buf, zfs_kernel_param_t kp)
	{
	uint64_t val;
	int error;

	error = kstrtoull(buf, 0, &val);
	if (error < 0)
	return (SET_ERROR(error));

	if (val > ASHIFT_MAX \|\| val < zfs_vdev_min_auto_ashift)
	return (SET_ERROR(-EINVAL));

	error = param_set_ulong(buf, kp);
	if (error < 0)
	return (SET_ERROR(error));

	return (0);
	}
	diff --git a/sys/contrib/openzfs/module/os/linux/zfs/zfs_acl.c b/sys/contrib/openzfs/module/os/linux/zfs/zfs_acl.c
	index f8bf55f75e97..cf37aecf8a22 100644
	--- a/sys/contrib/openzfs/module/os/linux/zfs/zfs_acl.c
	+++ b/sys/contrib/openzfs/module/os/linux/zfs/zfs_acl.c
	@@ -1,2948 +1,2948 @@
	/*
	* 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 2014 Nexenta Systems, Inc. All rights reserved.
	*/


	#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/sid.h>
	#include <sys/file.h>
	#include <sys/stat.h>
	#include <sys/kmem.h>
	#include <sys/cmn_err.h>
	#include <sys/errno.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 <sys/trace_acl.h>
	#include <sys/zpl.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)

	#define IDMAP_WK_CREATOR_OWNER_UID 2147483648U

	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 = {
	.ace_mask_get = zfs_ace_v0_get_mask,
	.ace_mask_set = zfs_ace_v0_set_mask,
	.ace_flags_get = zfs_ace_v0_get_flags,
	.ace_flags_set = zfs_ace_v0_set_flags,
	.ace_type_get = zfs_ace_v0_get_type,
	.ace_type_set = zfs_ace_v0_set_type,
	.ace_who_get = zfs_ace_v0_get_who,
	.ace_who_set = zfs_ace_v0_set_who,
	.ace_size = zfs_ace_v0_size,
	.ace_abstract_size = zfs_ace_v0_abstract_size,
	.ace_mask_off = zfs_ace_v0_mask_off,
	.ace_data = 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/
	+ 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 = {
	.ace_mask_get = zfs_ace_fuid_get_mask,
	.ace_mask_set = zfs_ace_fuid_set_mask,
	.ace_flags_get = zfs_ace_fuid_get_flags,
	.ace_flags_set = zfs_ace_fuid_set_flags,
	.ace_type_get = zfs_ace_fuid_get_type,
	.ace_type_set = zfs_ace_fuid_set_type,
	.ace_who_get = zfs_ace_fuid_get_who,
	.ace_who_set = zfs_ace_fuid_set_who,
	.ace_size = zfs_ace_fuid_size,
	.ace_abstract_size = zfs_ace_fuid_abstract_size,
	.ace_mask_off = zfs_ace_fuid_mask_off,
	.ace_data = 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(ZTOZSB(zp)),
	&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 = ZTOZSB(zp);
	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(ZTOZSB(zp)),
	&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(ZTOZSB(zp)->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(umode_t obj_mode, 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 (S_ISDIR(obj_mode) &&
	(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, umode_t obj_mode, 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_mode, 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(umode_t obj_mode, 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_mode, 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
	* every time.
	*/
	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(ZTOZSB(zp), ZTOI(zp)->i_mode,
	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(struct znode zp, boolean_t have_lock, zfs_acl_t *aclpp,
	boolean_t will_modify)
	{
	zfs_acl_t *aclp;
	int aclsize = 0;
	int acl_count = 0;
	zfs_acl_node_t *aclnode;
	zfs_acl_phys_t znode_acl;
	int version;
	int error;
	boolean_t drop_lock = B_FALSE;

	ASSERT(MUTEX_HELD(&zp->z_acl_lock));

	if (zp->z_acl_cached && !will_modify) {
	*aclpp = zp->z_acl_cached;
	return (0);
	}

	/*
	* close race where znode could be upgrade while trying to
	* read the znode attributes.
	*
	* But this could only happen if the file isn't already an SA
	* znode
	*/
	if (!zp->z_is_sa && !have_lock) {
	mutex_enter(&zp->z_lock);
	drop_lock = B_TRUE;
	}
	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(ZTOZSB(zp)->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(ZTOZSB(zp)),
	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:
	if (drop_lock)
	mutex_exit(&zp->z_lock);
	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 (ZTOZSB(zp)->z_acl_type == ZFS_ACLTYPE_POSIX)
	return (0);

	ASSERT(MUTEX_HELD(&zp->z_lock));
	ASSERT(MUTEX_HELD(&zp->z_acl_lock));

	error = zfs_acl_node_read(zp, B_TRUE, &aclp, B_FALSE);
	if (error == 0 && aclp->z_acl_count > 0)
	zp->z_mode = ZTOI(zp)->i_mode =
	zfs_mode_compute(zp->z_mode, aclp,
	&zp->z_pflags, KUID_TO_SUID(ZTOI(zp)->i_uid),
	KGID_TO_SGID(ZTOI(zp)->i_gid));

	/*
	* Some ZFS implementations (ZEVO) create neither a ZNODE_ACL
	* nor a DACL_ACES SA in which case ENOENT is returned from
	* zfs_acl_node_read() when the SA can't be located.
	* Allow chown/chgrp to succeed in these cases rather than
	* returning an error that makes no sense in the context of
	* the caller.
	*/
	if (error == ENOENT)
	return (0);

	return (error);
	}

	typedef struct trivial_acl {
	uint32_t allow0; /* allow mask for bits only in owner */
	uint32_t deny1; /* deny mask for bits not in owner */
	uint32_t deny2; /* deny mask for bits not in group */
	uint32_t owner; /* allow mask matching mode */
	uint32_t group; /* allow mask matching mode */
	uint32_t everyone; /* allow mask matching mode */
	} trivial_acl_t;

	static void
	acl_trivial_access_masks(mode_t mode, boolean_t isdir, trivial_acl_t *masks)
	{
	uint32_t read_mask = ACE_READ_DATA;
	uint32_t write_mask = ACE_WRITE_DATA\|ACE_APPEND_DATA;
	uint32_t execute_mask = ACE_EXECUTE;

	if (isdir)
	write_mask \|= ACE_DELETE_CHILD;

	masks->deny1 = 0;

	if (!(mode & S_IRUSR) && (mode & (S_IRGRP\|S_IROTH)))
	masks->deny1 \|= read_mask;
	if (!(mode & S_IWUSR) && (mode & (S_IWGRP\|S_IWOTH)))
	masks->deny1 \|= write_mask;
	if (!(mode & S_IXUSR) && (mode & (S_IXGRP\|S_IXOTH)))
	masks->deny1 \|= execute_mask;

	masks->deny2 = 0;
	if (!(mode & S_IRGRP) && (mode & S_IROTH))
	masks->deny2 \|= read_mask;
	if (!(mode & S_IWGRP) && (mode & S_IWOTH))
	masks->deny2 \|= write_mask;
	if (!(mode & S_IXGRP) && (mode & S_IXOTH))
	masks->deny2 \|= execute_mask;

	masks->allow0 = 0;
	if ((mode & S_IRUSR) && (!(mode & S_IRGRP) && (mode & S_IROTH)))
	masks->allow0 \|= read_mask;
	if ((mode & S_IWUSR) && (!(mode & S_IWGRP) && (mode & S_IWOTH)))
	masks->allow0 \|= write_mask;
	if ((mode & S_IXUSR) && (!(mode & S_IXGRP) && (mode & S_IXOTH)))
	masks->allow0 \|= execute_mask;

	masks->owner = ACE_WRITE_ATTRIBUTES\|ACE_WRITE_OWNER\|ACE_WRITE_ACL\|
	ACE_WRITE_NAMED_ATTRS\|ACE_READ_ACL\|ACE_READ_ATTRIBUTES\|
	ACE_READ_NAMED_ATTRS\|ACE_SYNCHRONIZE;
	if (mode & S_IRUSR)
	masks->owner \|= read_mask;
	if (mode & S_IWUSR)
	masks->owner \|= write_mask;
	if (mode & S_IXUSR)
	masks->owner \|= execute_mask;

	masks->group = ACE_READ_ACL\|ACE_READ_ATTRIBUTES\|ACE_READ_NAMED_ATTRS\|
	ACE_SYNCHRONIZE;
	if (mode & S_IRGRP)
	masks->group \|= read_mask;
	if (mode & S_IWGRP)
	masks->group \|= write_mask;
	if (mode & S_IXGRP)
	masks->group \|= execute_mask;

	masks->everyone = ACE_READ_ACL\|ACE_READ_ATTRIBUTES\|ACE_READ_NAMED_ATTRS\|
	ACE_SYNCHRONIZE;
	if (mode & S_IROTH)
	masks->everyone \|= read_mask;
	if (mode & S_IWOTH)
	masks->everyone \|= write_mask;
	if (mode & S_IXOTH)
	masks->everyone \|= execute_mask;
	}

	/*
	* ace_trivial:
	* determine whether an ace_t acl is trivial
	*
	* Trivialness implies that the acl is composed of only
	* owner, group, everyone entries. ACL can't
	* have read_acl denied, and write_owner/write_acl/write_attributes
	* can only be owner@ entry.
	*/
	static int
	ace_trivial_common(void *acep, int aclcnt,
	uint64_t (walk)(void , uint64_t, int aclcnt,
	uint16_t , uint16_t , uint32_t *))
	{
	uint16_t flags;
	uint32_t mask;
	uint16_t type;
	uint64_t cookie = 0;

	while ((cookie = walk(acep, cookie, aclcnt, &flags, &type, &mask))) {
	switch (flags & ACE_TYPE_FLAGS) {
	case ACE_OWNER:
	case ACE_GROUP\|ACE_IDENTIFIER_GROUP:
	case ACE_EVERYONE:
	break;
	default:
	return (1);
	}

	if (flags & (ACE_FILE_INHERIT_ACE\|
	ACE_DIRECTORY_INHERIT_ACE\|ACE_NO_PROPAGATE_INHERIT_ACE\|
	ACE_INHERIT_ONLY_ACE))
	return (1);

	/*
	* Special check for some special bits
	*
	* Don't allow anybody to deny reading basic
	* attributes or a files ACL.
	*/
	if ((mask & (ACE_READ_ACL\|ACE_READ_ATTRIBUTES)) &&
	(type == ACE_ACCESS_DENIED_ACE_TYPE))
	return (1);

	/*
	* Delete permission is never set by default
	*/
	if (mask & ACE_DELETE)
	return (1);

	/*
	* Child delete permission should be accompanied by write
	*/
	if ((mask & ACE_DELETE_CHILD) && !(mask & ACE_WRITE_DATA))
	return (1);

	/*
	* only allow owner@ to have
	* write_acl/write_owner/write_attributes/write_xattr/
	*/
	if (type == ACE_ACCESS_ALLOWED_ACE_TYPE &&
	(!(flags & ACE_OWNER) && (mask &
	(ACE_WRITE_OWNER\|ACE_WRITE_ACL\| ACE_WRITE_ATTRIBUTES\|
	ACE_WRITE_NAMED_ATTRS))))
	return (1);

	}

	return (0);
	}

	/*
	* 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 = ZTOZSB(zp);
	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;

	mode = zp->z_mode;

	mode = zfs_mode_compute(mode, aclp, &zp->z_pflags,
	KUID_TO_SUID(ZTOI(zp)->i_uid), KGID_TO_SGID(ZTOI(zp)->i_gid));

	zp->z_mode = ZTOI(zp)->i_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(boolean_t isdir, 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;
	trivial_acl_t masks;

	new_count = new_bytes = 0;

	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 to be no greater than
	* group permissions.
	* The "aclinherit" and "aclmode" properties
	* affect policy for create and chmod(2),
	* respectively.
	*/
	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);
	mutex_enter(&zp->z_lock);
	if (ZTOZSB(zp)->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(S_ISDIR(ZTOI(zp)->i_mode), mode, B_TRUE,
	(ZTOZSB(zp)->z_acl_mode == ZFS_ACL_GROUPMASK), *aclp);
	}
	mutex_exit(&zp->z_lock);
	mutex_exit(&zp->z_acl_lock);

	return (error);
	}

	/*
	* Should ACE be inherited?
	*/
	static int
	zfs_ace_can_use(umode_t obj_mode, uint16_t acep_flags)
	{
	int iflags = (acep_flags & 0xf);

	if (S_ISDIR(obj_mode) && (iflags & ACE_DIRECTORY_INHERIT_ACE))
	return (1);
	else if (iflags & ACE_FILE_INHERIT_ACE)
	return (!(S_ISDIR(obj_mode) &&
	(iflags & ACE_NO_PROPAGATE_INHERIT_ACE)));
	return (0);
	}

	/*
	* inherit inheritable ACEs from parent
	*/
	static zfs_acl_t *
	zfs_acl_inherit(zfsvfs_t zfsvfs, umode_t va_mode, 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 = S_ISDIR(va_mode);
	boolean_t isreg = S_ISREG(va_mode);

	*need_chmod = B_TRUE;

	aclp = zfs_acl_alloc(paclp->z_version);
	aclinherit = zfsvfs->z_acl_inherit;
	if (aclinherit == ZFS_ACL_DISCARD \|\| S_ISLNK(va_mode))
	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(va_mode, 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 = ZTOZSB(dzp);
	zfs_acl_t *paclp;
	gid_t gid = vap->va_gid;
	boolean_t need_chmod = B_TRUE;
	boolean_t trim = B_FALSE;
	boolean_t inherited = B_FALSE;

	bzero(acl_ids, sizeof (zfs_acl_ids_t));
	acl_ids->z_mode = vap->va_mode;

	if (vsecp)
	if ((error = zfs_vsec_2_aclp(zfsvfs, vap->va_mode, vsecp,
	cr, &acl_ids->z_fuidp, &acl_ids->z_aclp)) != 0)
	return (error);

	acl_ids->z_fuid = vap->va_uid;
	acl_ids->z_fgid = vap->va_gid;
	#ifdef HAVE_KSID
	/*
	* Determine uid and gid.
	*/
	if ((flag & IS_ROOT_NODE) \|\| zfsvfs->z_replay \|\|
	((flag & IS_XATTR) && (S_ISDIR(vap->va_mode)))) {
	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 != KGID_TO_SGID(ZTOI(dzp)->i_gid) &&
	!groupmember(vap->va_gid, cr) &&
	secpolicy_vnode_create_gid(cr) != 0)
	acl_ids->z_fgid = 0;
	}
	if (acl_ids->z_fgid == 0) {
	if (dzp->z_mode & S_ISGID) {
	char *domain;
	uint32_t rid;

	acl_ids->z_fgid = KGID_TO_SGID(
	ZTOI(dzp)->i_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);
	}
	} else {
	acl_ids->z_fgid = zfs_fuid_create_cred(zfsvfs,
	ZFS_GROUP, cr, &acl_ids->z_fuidp);
	gid = crgetgid(cr);
	}
	}
	}
	#endif /* HAVE_KSID */

	/*
	* 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) &&
	(S_ISDIR(vap->va_mode))) {
	acl_ids->z_mode \|= S_ISGID;
	} else {
	if ((acl_ids->z_mode & S_ISGID) &&
	secpolicy_vnode_setids_setgids(cr, gid) != 0)
	acl_ids->z_mode &= ~S_ISGID;
	}

	if (acl_ids->z_aclp == NULL) {
	mutex_enter(&dzp->z_acl_lock);
	mutex_enter(&dzp->z_lock);
	if (!(flag & IS_ROOT_NODE) &&
	(dzp->z_pflags & ZFS_INHERIT_ACE) &&
	!(dzp->z_pflags & ZFS_XATTR)) {
	VERIFY(0 == zfs_acl_node_read(dzp, B_TRUE,
	&paclp, B_FALSE));
	acl_ids->z_aclp = zfs_acl_inherit(zfsvfs,
	vap->va_mode, 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_lock);
	mutex_exit(&dzp->z_acl_lock);

	if (need_chmod) {
	if (S_ISDIR(vap->va_mode))
	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_mode, 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);

	error = zfs_acl_node_read(zp, B_FALSE, &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(ZTOZSB(zp), 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_mode,
	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_mode, 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_mode, 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 = ZTOZSB(zp);
	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 (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, ZTOI(zp)->i_mode, 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);
	mutex_enter(&zp->z_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);
	mutex_exit(&zp->z_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_lock);
	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) && (zfs_is_readonly(ZTOZSB(zp))) &&
	(!Z_ISDEV(ZTOI(zp)->i_mode) \|\|
	(Z_ISDEV(ZTOI(zp)->i_mode) && (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));
	}

	if ((v4_mode & (ACE_DELETE \| ACE_DELETE_CHILD)) &&
	(zp->z_pflags & ZFS_NOUNLINK)) {
	return (SET_ERROR(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
	* EACCES 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 = ZTOZSB(zp);
	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);

	error = zfs_acl_node_read(zp, B_FALSE, &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 (S_ISDIR(ZTOI(zp)->i_mode) &&
	(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/
	+ 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 != IDMAP_WK_CREATOR_OWNER_UID &&
	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(ZTOZSB(zp),
	KUID_TO_SUID(ZTOI(zp)->i_uid), cr, ZFS_OWNER);
	return (secpolicy_vnode_any_access(cr, ZTOI(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 = ZTOZSB(zp);
	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) &&
	S_ISDIR(ZTOI(zp)->i_mode) &&
	(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));
	}

	int
	zfs_fastaccesschk_execute(znode_t zdp, cred_t cr)
	{
	boolean_t owner = B_FALSE;
	boolean_t groupmbr = B_FALSE;
	boolean_t is_attr;
	uid_t uid = crgetuid(cr);
	int error;

	if (zdp->z_pflags & ZFS_AV_QUARANTINED)
	return (SET_ERROR(EACCES));

	is_attr = ((zdp->z_pflags & ZFS_XATTR) &&
	(S_ISDIR(ZTOI(zdp)->i_mode)));
	if (is_attr)
	goto slow;


	mutex_enter(&zdp->z_acl_lock);

	if (zdp->z_pflags & ZFS_NO_EXECS_DENIED) {
	mutex_exit(&zdp->z_acl_lock);
	return (0);
	}

	if (KUID_TO_SUID(ZTOI(zdp)->i_uid) != 0 \|\|
	KGID_TO_SGID(ZTOI(zdp)->i_gid) != 0) {
	mutex_exit(&zdp->z_acl_lock);
	goto slow;
	}

	if (uid == KUID_TO_SUID(ZTOI(zdp)->i_uid)) {
	owner = B_TRUE;
	if (zdp->z_mode & S_IXUSR) {
	mutex_exit(&zdp->z_acl_lock);
	return (0);
	} else {
	mutex_exit(&zdp->z_acl_lock);
	goto slow;
	}
	}
	if (groupmember(KGID_TO_SGID(ZTOI(zdp)->i_gid), cr)) {
	groupmbr = B_TRUE;
	if (zdp->z_mode & S_IXGRP) {
	mutex_exit(&zdp->z_acl_lock);
	return (0);
	} else {
	mutex_exit(&zdp->z_acl_lock);
	goto slow;
	}
	}
	if (!owner && !groupmbr) {
	if (zdp->z_mode & S_IXOTH) {
	mutex_exit(&zdp->z_acl_lock);
	return (0);
	}
	}

	mutex_exit(&zdp->z_acl_lock);

	slow:
	DTRACE_PROBE(zfs__fastpath__execute__access__miss);
	ZFS_ENTER(ZTOZSB(zdp));
	error = zfs_zaccess(zdp, ACE_EXECUTE, 0, B_FALSE, cr);
	ZFS_EXIT(ZTOZSB(zdp));
	return (error);
	}

	/*
	* 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;
	znode_t *check_zp = zp;
	mode_t needed_bits;
	uid_t owner;

	is_attr = ((zp->z_pflags & ZFS_XATTR) && S_ISDIR(ZTOI(zp)->i_mode));

	/*
	* If attribute then validate against base file
	*/
	if (is_attr) {
	if ((error = zfs_zget(ZTOZSB(zp),
	zp->z_xattr_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;
	}
	}

	owner = zfs_fuid_map_id(ZTOZSB(zp), KUID_TO_SUID(ZTOI(zp)->i_uid),
	cr, ZFS_OWNER);
	/*
	* Map the bits required to the standard inode flags
	* S_IRUSR\|S_IWUSR\|S_IXUSR in the 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 \|= S_IRUSR;
	if (working_mode & (ACE_WRITE_DATA\|ACE_WRITE_NAMED_ATTRS\|
	ACE_APPEND_DATA\|ACE_WRITE_ATTRIBUTES\|ACE_SYNCHRONIZE))
	needed_bits \|= S_IWUSR;
	if (working_mode & ACE_EXECUTE)
	needed_bits \|= S_IXUSR;

	if ((error = zfs_zaccess_common(check_zp, mode, &working_mode,
	&check_privs, skipaclchk, cr)) == 0) {
	if (is_attr)
	zrele(xzp);
	return (secpolicy_vnode_access2(cr, ZTOI(zp), owner,
	needed_bits, needed_bits));
	}

	if (error && !check_privs) {
	if (is_attr)
	zrele(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;

	/*
	* 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 \|= S_IRUSR;
	if (working_mode & (ACE_WRITE_DATA\|ACE_WRITE_NAMED_ATTRS\|
	ACE_APPEND_DATA\|ACE_WRITE_ATTRIBUTES\|ACE_SYNCHRONIZE))
	checkmode \|= S_IWUSR;
	if (working_mode & ACE_EXECUTE)
	checkmode \|= S_IXUSR;

	error = secpolicy_vnode_access2(cr, ZTOI(check_zp), owner,
	needed_bits & ~checkmode, needed_bits);

	if (error == 0 && (working_mode & ACE_WRITE_OWNER))
	error = secpolicy_vnode_chown(cr, owner);
	if (error == 0 && (working_mode & ACE_WRITE_ACL))
	error = secpolicy_vnode_setdac(cr, owner);

	if (error == 0 && (working_mode &
	(ACE_DELETE\|ACE_DELETE_CHILD)))
	error = secpolicy_vnode_remove(cr);

	if (error == 0 && (working_mode & ACE_SYNCHRONIZE)) {
	error = secpolicy_vnode_chown(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, ZTOI(zp), owner,
	needed_bits, needed_bits);
	}

	if (is_attr)
	zrele(xzp);

	return (error);
	}

	/*
	* Translate traditional unix S_IRUSR/S_IWUSR/S_IXUSR 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));
	}

	/* See zfs_zaccess_delete() */
	int zfs_write_implies_delete_child = 1;

	/*
	* Determine whether delete access should be granted.
	*
	* The following chart outlines how we handle delete permissions which is
	* how recent versions of windows (Windows 2008) handles it. The efficiency
	* comes from not having to check the parent ACL where the object itself grants
	* delete:
	*
	* -------------------------------------------------------
	* \| Parent Dir \| Target Object Permissions \|
	* \| permissions \| \|
	* -------------------------------------------------------
	* \| \| ACL Allows \| ACL Denies\| Delete \|
	* \| \| Delete \| Delete \| unspecified\|
	* -------------------------------------------------------
	* \| ACL Allows \| Permit \| Deny * \| Permit \|
	* \| DELETE_CHILD \| \| \| \|
	* -------------------------------------------------------
	* \| ACL Denies \| Permit \| Deny \| Deny \|
	* \| DELETE_CHILD \| \| \| \|
	* -------------------------------------------------------
	* \| ACL specifies \| \| \| \|
	* \| only allow \| Permit \| Deny * \| Permit \|
	* \| write and \| \| \| \|
	* \| execute \| \| \| \|
	* -------------------------------------------------------
	* \| ACL denies \| \| \| \|
	* \| write and \| Permit \| Deny \| Deny \|
	* \| execute \| \| \| \|
	* -------------------------------------------------------
	* ^
	* \|
	* Re. execute permission on the directory: if that's missing,
	* the vnode lookup of the target will fail before we get here.
	*
	* Re [*] in the table above: NFSv4 would normally Permit delete for
	* these two cells of the matrix.
	* See acl.h for notes on which ACE_... flags should be checked for which
	* operations. Specifically, the NFSv4 committee recommendation is in
	* conflict with the Windows interpretation of DENY ACEs, where DENY ACEs
	* should take precedence ahead of ALLOW ACEs.
	*
	* This implementation always consults the target object's ACL first.
	* If a DENY ACE is present on the target object that specifies ACE_DELETE,
	* delete access is denied. If an ALLOW ACE with ACE_DELETE is present on
	* the target object, access is allowed. If and only if no entries with
	* ACE_DELETE are present in the object's ACL, check the container's ACL
	* for entries with ACE_DELETE_CHILD.
	*
	* A summary of the logic implemented from the table above is as follows:
	*
	* First check for DENY ACEs that apply.
	* If either target or container has a deny, EACCES.
	*
	* Delete access can then be summarized as follows:
	* 1: The object to be deleted grants ACE_DELETE, or
	* 2: The containing directory grants ACE_DELETE_CHILD.
	* In a Windows system, that would be the end of the story.
	* In this system, (2) has some complications...
	* 2a: "sticky" bit on a directory adds restrictions, and
	* 2b: existing ACEs from previous versions of ZFS may
	* not carry ACE_DELETE_CHILD where they should, so we
	* also allow delete when ACE_WRITE_DATA is granted.
	*
	* Note: 2b is technically a work-around for a prior bug,
	* which hopefully can go away some day. For those who
	* no longer need the work around, and for testing, this
	* work-around is made conditional via the tunable:
	* zfs_write_implies_delete_child
	*/
	int
	zfs_zaccess_delete(znode_t dzp, znode_t zp, cred_t *cr)
	{
	uint32_t wanted_dirperms;
	uint32_t dzp_working_mode = 0;
	uint32_t zp_working_mode = 0;
	int dzp_error, zp_error;
	boolean_t dzpcheck_privs;
	boolean_t zpcheck_privs;

	if (zp->z_pflags & (ZFS_IMMUTABLE \| ZFS_NOUNLINK))
	return (SET_ERROR(EPERM));

	/*
	* Case 1:
	* If target object grants ACE_DELETE then we are done. This is
	* indicated by a return value of 0. For this case we don't worry
	* about the sticky bit because sticky only applies to the parent
	* directory and this is the child access result.
	*
	* If we encounter a DENY ACE here, we're also done (EACCES).
	* Note that if we hit a DENY ACE here (on the target) it should
	* take precedence over a DENY ACE on the container, so that when
	* we have more complete auditing support we will be able to
	* report an access failure against the specific target.
	* (This is part of why we're checking the target first.)
	*/
	zp_error = zfs_zaccess_common(zp, ACE_DELETE, &zp_working_mode,
	&zpcheck_privs, B_FALSE, cr);
	if (zp_error == EACCES) {
	/* We hit a DENY ACE. */
	if (!zpcheck_privs)
	return (SET_ERROR(zp_error));
	return (secpolicy_vnode_remove(cr));

	}
	if (zp_error == 0)
	return (0);

	/*
	* Case 2:
	* If the containing directory grants ACE_DELETE_CHILD,
	* or we're in backward compatibility mode and the
	* containing directory has ACE_WRITE_DATA, allow.
	* Case 2b is handled with wanted_dirperms.
	*/
	wanted_dirperms = ACE_DELETE_CHILD;
	if (zfs_write_implies_delete_child)
	wanted_dirperms \|= ACE_WRITE_DATA;
	dzp_error = zfs_zaccess_common(dzp, wanted_dirperms,
	&dzp_working_mode, &dzpcheck_privs, B_FALSE, cr);
	if (dzp_error == EACCES) {
	/* We hit a DENY ACE. */
	if (!dzpcheck_privs)
	return (SET_ERROR(dzp_error));
	return (secpolicy_vnode_remove(cr));
	}

	/*
	* Cases 2a, 2b (continued)
	*
	* Note: dzp_working_mode now contains any permissions
	* that were NOT granted. Therefore, if any of the
	* wanted_dirperms WERE granted, we will have:
	* dzp_working_mode != wanted_dirperms
	* We're really asking if ANY of those permissions
	* were granted, and if so, grant delete access.
	*/
	if (dzp_working_mode != wanted_dirperms)
	dzp_error = 0;

	/*
	* dzp_error is 0 if the container granted us permissions to "modify".
	* If we do not have permission via one or more ACEs, our current
	* privileges may still permit us to modify the container.
	*
	* dzpcheck_privs is false when i.e. the FS is read-only.
	* Otherwise, do privilege checks for the container.
	*/
	if (dzp_error != 0 && dzpcheck_privs) {
	uid_t owner;

	/*
	* The secpolicy call needs the requested access and
	* the current access mode of the container, but it
	* only knows about Unix-style modes (VEXEC, VWRITE),
	* so this must condense the fine-grained ACE bits into
	* Unix modes.
	*
	* The VEXEC flag is easy, because we know that has
	* always been checked before we get here (during the
	* lookup of the target vnode). The container has not
	* granted us permissions to "modify", so we do not set
	* the VWRITE flag in the current access mode.
	*/
	owner = zfs_fuid_map_id(ZTOZSB(dzp),
	KUID_TO_SUID(ZTOI(dzp)->i_uid), cr, ZFS_OWNER);
	dzp_error = secpolicy_vnode_access2(cr, ZTOI(dzp),
	owner, S_IXUSR, S_IWUSR\|S_IXUSR);
	}
	if (dzp_error != 0) {
	/*
	* Note: We may have dzp_error = -1 here (from
	* zfs_zacess_common). Don't return that.
	*/
	return (SET_ERROR(EACCES));
	}


	/*
	* At this point, we know that the directory permissions allow
	* us to modify, but we still need to check for the additional
	* restrictions that apply when the "sticky bit" is set.
	*
	* Yes, zfs_sticky_remove_access() also checks this bit, but
	* checking it here and skipping the call below is nice when
	* you're watching all of this with dtrace.
	*/
	if ((dzp->z_mode & S_ISVTX) == 0)
	return (0);

	/*
	* zfs_sticky_remove_access will succeed if:
	* 1. The sticky bit is absent.
	* 2. We pass the sticky bit restrictions.
	* 3. We have privileges that always allow file removal.
	*/
	return (zfs_sticky_remove_access(dzp, zp, 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 = S_ISDIR(ZTOI(szp)->i_mode) ?
	ACE_ADD_SUBDIRECTORY : ACE_ADD_FILE;

	/*
	* Rename permissions are combination of delete permission +
	* add file/subdir permission.
	*/

	/*
	* 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) {
	if ((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/linux/zfs/zfs_vnops_os.c b/sys/contrib/openzfs/module/os/linux/zfs/zfs_vnops_os.c
	index ef99c4864d3c..a1a0e44bb31f 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,4024 +1,4028 @@
	/*
	* 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);
	}

	static void
	zfs_rele_async_task(void *arg)
	{
	iput(arg);
	}

	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)),
	zfs_rele_async_task, 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 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))
	+#ifdef HAVE_PAGEMAP_FOLIO_WAIT_BIT
	+ folio_wait_bit(page_folio(pp), PG_writeback);
	+#else
	wait_on_page_bit(pp, PG_writeback);
	+#endif
	}

	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 c841cc0fc8b5..cd80049df142 100644
	--- a/sys/contrib/openzfs/module/os/linux/zfs/zfs_znode.c
	+++ b/sys/contrib/openzfs/module/os/linux/zfs/zfs_znode.c
	@@ -1,2255 +1,2255 @@
	/*
	* 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 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/
	+ 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], btime[2];
	uint64_t projid = ZFS_DEFAULT_PROJID;
	sa_bulk_attr_t bulk[12];
	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);
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_CRTIME(zfsvfs), NULL, &btime, 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);
	ZFS_TIME_DECODE(&zp->z_btime, btime);

	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.
	*
	* Exceptions include rolling back a mounted file system, either
	* from the zfs rollback or zfs recv command.
	*
	* Active inodes are unhashed during the rollback, but since zrele
	* can happen asynchronously, we can't guarantee they've been
	* unhashed. This can cause hash collisions in unlinked drain
	* processing so do not hash unlinked znodes.
	*/
	if (links > 0)
	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);

	if (links > 0)
	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[11];
	int err;
	int count = 0;
	uint64_t gen;
	uint64_t z_uid, z_gid;
	uint64_t atime[2], mtime[2], ctime[2], btime[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);
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_CRTIME(zfsvfs), NULL, &btime, 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);
	ZFS_TIME_DECODE(&zp->z_btime, btime);

	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/zpl_file.c b/sys/contrib/openzfs/module/os/linux/zfs/zpl_file.c
	index 63002fe3b932..7e88eae33711 100644
	--- a/sys/contrib/openzfs/module/os/linux/zfs/zpl_file.c
	+++ b/sys/contrib/openzfs/module/os/linux/zfs/zpl_file.c
	@@ -1,1083 +1,1089 @@
	/*
	* 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>
	#ifdef HAVE_VFS_SET_PAGE_DIRTY_NOBUFFERS
	#include <linux/pagemap.h>
	#endif

	/*
	* 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 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
	+#ifdef HAVE_IOV_ITER_TYPE
	+ zfs_uio_iovec_init(uio, to->iov, to->nr_segs, pos,
	+ iov_iter_type(to) & ITER_KVEC ? UIO_SYSSPACE : UIO_USERSPACE,
	+ 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
	+#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;

	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 inline int
	zpl_readpage_common(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);
	}

	static int
	zpl_readpage(struct file filp, struct page pp)
	{
	return (zpl_readpage_common(pp));
	}

	static int
	zpl_readpage_filler(void data, struct page pp)
	{
	return (zpl_readpage_common(pp));
	}

	/*
	* 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, zpl_readpage_filler, NULL));
	}

	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,
	#ifdef HAVE_VFS_SET_PAGE_DIRTY_NOBUFFERS
	.set_page_dirty = __set_page_dirty_nobuffers,
	#endif
	};

	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/zvol_os.c b/sys/contrib/openzfs/module/os/linux/zfs/zvol_os.c
	index c17423426319..44caadd587f7 100644
	--- a/sys/contrib/openzfs/module/os/linux/zfs/zvol_os.c
	+++ b/sys/contrib/openzfs/module/os/linux/zfs/zvol_os.c
	@@ -1,1174 +1,1231 @@
	/*
	* 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;
	+unsigned int zvol_open_timeout_ms = 1000;

	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
	+#ifdef HAVE_BDEV_SUBMIT_BIO_RETURNS_VOID
	+static void
	+zvol_submit_bio(struct bio *bio)
	+#else
	static blk_qc_t
	zvol_submit_bio(struct bio *bio)
	+#endif
	#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)
	+#if (defined(HAVE_MAKE_REQUEST_FN_RET_QC) \|\| \
	+ defined(HAVE_SUBMIT_BIO_IN_BLOCK_DEVICE_OPERATIONS)) && \
	+ !defined(HAVE_BDEV_SUBMIT_BIO_RETURNS_VOID)
	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;
	+ boolean_t drop_namespace = B_FALSE;
	+#ifndef HAVE_BLKDEV_GET_ERESTARTSYS
	+ hrtime_t timeout = MSEC2NSEC(zvol_open_timeout_ms);
	+ hrtime_t start = gethrtime();

	+retry:
	+#endif
	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));
	}

	+ if (zv->zv_open_count == 0 && !mutex_owned(&spa_namespace_lock)) {
	+ /*
	+ * In all other call paths the spa_namespace_lock is taken
	+ * before the bdev->bd_mutex lock. However, on open(2)
	+ * the __blkdev_get() function calls fops->open() with the
	+ * bdev->bd_mutex lock held. This can result in a deadlock
	+ * when zvols from one pool are used as vdevs in another.
	+ *
	+ * To prevent a lock inversion deadlock we preemptively
	+ * take the spa_namespace_lock. Normally the lock will not
	+ * be contended and this is safe because spa_open_common()
	+ * handles the case where the caller already holds the
	+ * spa_namespace_lock.
	+ *
	+ * When the lock cannot be aquired after multiple retries
	+ * this must be the vdev on zvol deadlock case and we have
	+ * no choice but to return an error. For 5.12 and older
	+ * kernels returning -ERESTARTSYS will result in the
	+ * bdev->bd_mutex being dropped, then reacquired, and
	+ * fops->open() being called again. This process can be
	+ * repeated safely until both locks are acquired. For 5.13
	+ * and newer the -ERESTARTSYS retry logic was removed from
	+ * the kernel so the only option is to return the error for
	+ * the caller to handle it.
	+ */
	+ if (!mutex_tryenter(&spa_namespace_lock)) {
	+ rw_exit(&zvol_state_lock);
	+
	+#ifdef HAVE_BLKDEV_GET_ERESTARTSYS
	+ schedule();
	+ return (SET_ERROR(-ERESTARTSYS));
	+#else
	+ if ((gethrtime() - start) > timeout)
	+ return (SET_ERROR(-ERESTARTSYS));
	+
	+ schedule_timeout(MSEC_TO_TICK(10));
	+ goto retry;
	+#endif
	+ } else {
	+ drop_namespace = B_TRUE;
	+ }
	+ }
	+
	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_namespace)
	+ mutex_exit(&spa_namespace_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_namespace)
	+ mutex_exit(&spa_namespace_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
	#ifdef HAVE_BLK_ALLOC_DISK
	zso->zvo_disk = blk_alloc_disk(NUMA_NO_NODE);
	if (zso->zvo_disk == NULL)
	goto out_kmem;

	zso->zvo_disk->minors = ZVOL_MINORS;
	zso->zvo_queue = zso->zvo_disk->queue;
	#else
	zso->zvo_queue = blk_alloc_queue(NUMA_NO_NODE);
	if (zso->zvo_queue == NULL)
	goto out_kmem;

	zso->zvo_disk = alloc_disk(ZVOL_MINORS);
	if (zso->zvo_disk == NULL) {
	blk_cleanup_queue(zso->zvo_queue);
	goto out_kmem;
	}

	zso->zvo_disk->queue = zso->zvo_queue;
	#endif /* HAVE_BLK_ALLOC_DISK */
	#else
	zso->zvo_queue = blk_generic_alloc_queue(zvol_request, NUMA_NO_NODE);
	if (zso->zvo_queue == NULL)
	goto out_kmem;

	zso->zvo_disk = alloc_disk(ZVOL_MINORS);
	if (zso->zvo_disk == NULL) {
	blk_cleanup_queue(zso->zvo_queue);
	goto out_kmem;
	}

	zso->zvo_disk->queue = zso->zvo_queue;
	#endif /* HAVE_SUBMIT_BIO_IN_BLOCK_DEVICE_OPERATIONS */

	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);

	/* Enable /proc/diskstats */
	blk_queue_flag_set(QUEUE_FLAG_IO_STAT, zso->zvo_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;
	snprintf(zso->zvo_disk->disk_name, DISK_NAME_LEN, "%s%d",
	ZVOL_DEV_NAME, (dev & MINORMASK));

	return (zv);

	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);
	#if defined(HAVE_SUBMIT_BIO_IN_BLOCK_DEVICE_OPERATIONS) && \
	defined(HAVE_BLK_ALLOC_DISK)
	blk_cleanup_disk(zv->zv_zso->zvo_disk);
	#else
	blk_cleanup_queue(zv->zv_zso->zvo_queue);
	put_disk(zv->zv_zso->zvo_disk);
	#endif

	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 c1d9a325f511..bce5f19625cb 100644
	--- a/sys/contrib/openzfs/module/unicode/u8_textprep.c
	+++ b/sys/contrib/openzfs/module/unicode/u8_textprep.c
	@@ -1,2151 +1,2155 @@
	/*
	* 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 {
	+ // cppcheck-suppress arrayIndexOutOfBoundsCond
	start_id = u8_decomp_b4_tbl[uv][b3_tbl][b4];
	+ // cppcheck-suppress arrayIndexOutOfBoundsCond
	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 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 {
	+ // cppcheck-suppress arrayIndexOutOfBoundsCond
	start_id = u8_composition_b4_tbl[uv][b3_tbl][b4];
	+ // cppcheck-suppress arrayIndexOutOfBoundsCond
	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/zfs/abd.c b/sys/contrib/openzfs/module/zfs/abd.c
	index cc2d3575db63..03a7b1e033b3 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)
	{
	#ifdef ZFS_DEBUG
	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));
	IMPLY(abd->abd_parent != NULL, !(abd->abd_flags & ABD_FLAG_OWNER));
	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);
	}
	#endif
	}

	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 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, size);
	}

	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 */
	+ fallthrough;
	case 2:
	len = MIN(caiters[1].iter_mapsize, len);
	- /* falls through */
	+ fallthrough;
	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 */
	+ fallthrough;
	case 2:
	len = MIN(xiters[1].iter_mapsize, len);
	len = MIN(citers[1].iter_mapsize, len);
	- /* falls through */
	+ fallthrough;
	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 b864394b42a0..875986de99f0 100644
	--- a/sys/contrib/openzfs/module/zfs/arc.c
	+++ b/sys/contrib/openzfs/module/zfs/arc.c
	@@ -1,11110 +1,11109 @@
	/*
	* 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 <sys/wmsum.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 },
	};

	arc_sums_t arc_sums;

	#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; \
	}

	/*
	* 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;

	/*
	* 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_need_free ARCSTAT(arcstat_need_free) /* waiting to be evicted */

	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 BUF_LOCKS 2048
	typedef struct buf_hash_table {
	uint64_t ht_mask;
	arc_buf_hdr_t **ht_table;
	kmutex_t ht_locks[BUF_LOCKS] ____cacheline_aligned;
	} 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(idx) (&buf_hash_table.ht_locks[idx & (BUF_LOCKS-1)])
	#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

	/* 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;

	typedef enum arc_ovf_level {
	ARC_OVF_NONE, /* ARC within target size. */
	ARC_OVF_SOME, /* ARC is slightly overflowed. */
	ARC_OVF_SEVERE /* ARC is severely overflowed. */
	} arc_ovf_level_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,
	ARC_HDR_USE_RESERVE = 0x4,
	};


	static abd_t arc_get_data_abd(arc_buf_hdr_t , uint64_t, void *, int);
	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 , int);
	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);
	}
	uint64_t he = atomic_inc_64_nv(
	&arc_stats.arcstat_hash_elements.value.ui64);
	ARCSTAT_MAX(arcstat_hash_elements_max, he);

	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 */
	atomic_dec_64(&arc_stats.arcstat_hash_elements.value.ui64);

	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_LOCK(i));
	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_LOCK(i), 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,
	ARC_HDR_DO_ADAPT);
	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;
	}

	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;
	}

	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);
	}
	}
	}

	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:
	ARCSTAT_INCR(arcstat_data_size, space);
	break;
	case ARC_SPACE_META:
	ARCSTAT_INCR(arcstat_metadata_size, space);
	break;
	case ARC_SPACE_BONUS:
	ARCSTAT_INCR(arcstat_bonus_size, space);
	break;
	case ARC_SPACE_DNODE:
	aggsum_add(&arc_sums.arcstat_dnode_size, space);
	break;
	case ARC_SPACE_DBUF:
	ARCSTAT_INCR(arcstat_dbuf_size, space);
	break;
	case ARC_SPACE_HDRS:
	ARCSTAT_INCR(arcstat_hdr_size, space);
	break;
	case ARC_SPACE_L2HDRS:
	aggsum_add(&arc_sums.arcstat_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.
	*/
	ARCSTAT_INCR(arcstat_abd_chunk_waste_size, space);
	break;
	}

	if (type != ARC_SPACE_DATA && type != ARC_SPACE_ABD_CHUNK_WASTE)
	aggsum_add(&arc_sums.arcstat_meta_used, space);

	aggsum_add(&arc_sums.arcstat_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:
	ARCSTAT_INCR(arcstat_data_size, -space);
	break;
	case ARC_SPACE_META:
	ARCSTAT_INCR(arcstat_metadata_size, -space);
	break;
	case ARC_SPACE_BONUS:
	ARCSTAT_INCR(arcstat_bonus_size, -space);
	break;
	case ARC_SPACE_DNODE:
	aggsum_add(&arc_sums.arcstat_dnode_size, -space);
	break;
	case ARC_SPACE_DBUF:
	ARCSTAT_INCR(arcstat_dbuf_size, -space);
	break;
	case ARC_SPACE_HDRS:
	ARCSTAT_INCR(arcstat_hdr_size, -space);
	break;
	case ARC_SPACE_L2HDRS:
	aggsum_add(&arc_sums.arcstat_l2_hdr_size, -space);
	break;
	case ARC_SPACE_ABD_CHUNK_WASTE:
	ARCSTAT_INCR(arcstat_abd_chunk_waste_size, -space);
	break;
	}

	if (type != ARC_SPACE_DATA && type != ARC_SPACE_ABD_CHUNK_WASTE) {
	ASSERT(aggsum_compare(&arc_sums.arcstat_meta_used,
	space) >= 0);
	ARCSTAT_MAX(arcstat_meta_max,
	aggsum_upper_bound(&arc_sums.arcstat_meta_used));
	aggsum_add(&arc_sums.arcstat_meta_used, -space);
	}

	ASSERT(aggsum_compare(&arc_sums.arcstat_size, space) >= 0);
	aggsum_add(&arc_sums.arcstat_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);

	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);

	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,
	alloc_flags);
	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,
	alloc_flags);
	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));
	}

	/*
	* Allocate empty anonymous ARC header. The header will get its identity
	* assigned and buffers attached later as part of read or write operations.
	*
	* In case of read arc_read() assigns header its identify (b_dva + b_birth),
	* inserts it into ARC hash to become globally visible and allocates physical
	* (b_pabd) or raw (b_rabd) ABD buffer to read into from disk. On disk read
	* completion arc_read_done() allocates ARC buffer(s) as needed, potentially
	* sharing one of them with the physical ABD buffer.
	*
	* In case of write arc_alloc_buf() allocates ARC buffer to be filled with
	* data. Then after compression and/or encryption arc_write_ready() allocates
	* and fills (or potentially shares) physical (b_pabd) or raw (b_rabd) ABD
	* buffer. On disk write completion arc_write_done() assigns the header its
	* new identity (b_dva + b_birth) and inserts into ARC hash.
	*
	* In case of partial overwrite the old data is read first as described. Then
	* arc_release() either allocates new anonymous ARC header and moves the ARC
	* buffer to it, or reuses the old ARC header by discarding its identity and
	* removing it from ARC hash. After buffer modification normal write process
	* follows as described.
	*/
	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)
	{
	arc_buf_hdr_t *hdr;

	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);
	}

	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_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_bufcnt = 0;
	hdr->b_l1hdr.b_buf = NULL;

	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_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_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);

	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);

	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);

	/*
	* 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_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);

	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
	*
	* Return total size of evicted data buffers for eviction progress tracking.
	* When evicting from ghost states return logical buffer size to make eviction
	* progress at the same (or at least comparable) rate as from non-ghost states.
	*
	* Return *real_evicted for actual ARC size reduction to wake up threads
	* waiting for it. For non-ghost states it includes size of evicted data
	* buffers (the headers are not freed there). For ghost states it includes
	* only the evicted headers size.
	*/
	static int64_t
	arc_evict_hdr(arc_buf_hdr_t hdr, kmutex_t hash_lock, uint64_t *real_evicted)
	{
	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));

	*real_evicted = 0;
	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);
	*real_evicted += HDR_FULL_SIZE - HDR_L2ONLY_SIZE;
	} else {
	arc_change_state(arc_anon, hdr, hash_lock);
	arc_hdr_destroy(hdr);
	*real_evicted += HDR_FULL_SIZE;
	}
	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);
	*real_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);
	*real_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, uint64_t bytes)
	{
	multilist_sublist_t *mls;
	uint64_t bytes_evicted = 0, real_evicted = 0;
	arc_buf_hdr_t *hdr;
	kmutex_t *hash_lock;
	int evict_count = zfs_arc_evict_batch_limit;

	ASSERT3P(marker, !=, NULL);

	mls = multilist_sublist_lock(ml, idx);

	for (hdr = multilist_sublist_prev(mls, marker); likely(hdr != NULL);
	hdr = multilist_sublist_prev(mls, marker)) {
	if ((evict_count <= 0) \|\| (bytes_evicted >= bytes))
	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 revicted;
	uint64_t evicted = arc_evict_hdr(hdr, hash_lock,
	&revicted);
	mutex_exit(hash_lock);

	bytes_evicted += evicted;
	real_evicted += revicted;

	/*
	* 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 += real_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, uint64_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;

	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) {
	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(
	&arc_sums.arcstat_dnode_size, arc_dnode_size_limit) > 0) {
	arc_prune_async((aggsum_upper_bound(
	&arc_sums.arcstat_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 (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)
	{
	uint64_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 arcstat_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 arcstat_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_sums.arcstat_size);
	uint64_t ameta = aggsum_value(&arc_sums.arcstat_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_sums.arcstat_size);
	ameta = aggsum_value(&arc_sums.arcstat_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_sums.arcstat_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_sums.arcstat_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_sums.arcstat_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 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_sums.arcstat_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.
	*/
	static arc_ovf_level_t
	arc_is_overflowing(boolean_t use_reserve)
	{
	/* 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.
	*/
	int64_t over = aggsum_lower_bound(&arc_sums.arcstat_size) -
	arc_c - overflow / 2;
	if (!use_reserve)
	overflow /= 2;
	return (over < 0 ? ARC_OVF_NONE :
	over < overflow ? ARC_OVF_SOME : ARC_OVF_SEVERE);
	}

	static abd_t *
	arc_get_data_abd(arc_buf_hdr_t hdr, uint64_t size, void tag,
	int alloc_flags)
	{
	arc_buf_contents_t type = arc_buf_type(hdr);

	arc_get_data_impl(hdr, size, tag, alloc_flags);
	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, ARC_HDR_DO_ADAPT);
	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, boolean_t use_reserve)
	{
	switch (arc_is_overflowing(use_reserve)) {
	case ARC_OVF_NONE:
	return;
	case ARC_OVF_SOME:
	/*
	* This is a bit racy without taking arc_evict_lock, but the
	* worst that can happen is we either call zthr_wakeup() extra
	* time due to race with other thread here, or the set flag
	* get cleared by arc_evict_cb(), which is unlikely due to
	* big hysteresis, but also not important since at this level
	* of overflow the eviction is purely advisory. Same time
	* taking the global lock here every time without waiting for
	* the actual eviction creates a significant lock contention.
	*/
	if (!arc_evict_needed) {
	arc_evict_needed = B_TRUE;
	zthr_wakeup(arc_evict_zthr);
	}
	return;
	case ARC_OVF_SEVERE:
	default:
	{
	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;
	mutex_enter(&arc_evict_lock);
	if (!list_is_empty(&arc_evict_waiters)) {
	arc_evict_waiter_t *last =
	list_tail(&arc_evict_waiters);
	last_count = last->aew_count;
	} else if (!arc_evict_needed) {
	arc_evict_needed = B_TRUE;
	zthr_wakeup(arc_evict_zthr);
	}
	/*
	* 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.
	* In case of "false" wakeup, we will still be on the list.
	*/
	do {
	cv_wait(&aw.aew_cv, &arc_evict_lock);
	} while (list_link_active(&aw.aew_node));
	mutex_exit(&arc_evict_lock);

	cv_destroy(&aw.aew_cv);
	}
	}
	}

	/*
	* 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,
	int alloc_flags)
	{
	arc_state_t *state = hdr->b_l1hdr.b_state;
	arc_buf_contents_t type = arc_buf_type(hdr);

	if (alloc_flags & ARC_HDR_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.
	*/
	arc_wait_for_eviction(size * zfs_arc_eviction_pct / 100,
	alloc_flags & ARC_HDR_USE_RESERVE);

	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_sums.arcstat_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);
	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);
	}
	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);

	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.
	*/

	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);

	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:
	/*
	* Verify the block pointer contents are reasonable. This should
	* always be the case since the blkptr is protected by a checksum.
	* However, if there is damage it's desirable to detect this early
	* and treat it as a checksum error. This allows an alternate blkptr
	* to be tried when one is available (e.g. ditto blocks).
	*/
	if (!zfs_blkptr_verify(spa, bp, zio_flags & ZIO_FLAG_CONFIG_WRITER,
	BLK_VERIFY_LOG)) {
	rc = SET_ERROR(ECKSUM);
	goto out;
	}

	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;
	}

	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);

	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 */
	}
	alloc_flags \|= ARC_HDR_DO_ADAPT;
	} 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);
	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));

	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);
	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;
	(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;
	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 \|
	ARC_HDR_USE_RESERVE);
	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 \| ARC_HDR_USE_RESERVE);
	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 \|
	ARC_HDR_USE_RESERVE);
	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 \|
	ARC_HDR_USE_RESERVE);
	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",
	(u_longlong_t)arc_tempreserve >> 10,
	(u_longlong_t)meta_esize >> 10,
	(u_longlong_t)data_esize >> 10,
	(u_longlong_t)reserve >> 10,
	(u_longlong_t)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));

	as->arcstat_hits.value.ui64 =
	wmsum_value(&arc_sums.arcstat_hits);
	as->arcstat_misses.value.ui64 =
	wmsum_value(&arc_sums.arcstat_misses);
	as->arcstat_demand_data_hits.value.ui64 =
	wmsum_value(&arc_sums.arcstat_demand_data_hits);
	as->arcstat_demand_data_misses.value.ui64 =
	wmsum_value(&arc_sums.arcstat_demand_data_misses);
	as->arcstat_demand_metadata_hits.value.ui64 =
	wmsum_value(&arc_sums.arcstat_demand_metadata_hits);
	as->arcstat_demand_metadata_misses.value.ui64 =
	wmsum_value(&arc_sums.arcstat_demand_metadata_misses);
	as->arcstat_prefetch_data_hits.value.ui64 =
	wmsum_value(&arc_sums.arcstat_prefetch_data_hits);
	as->arcstat_prefetch_data_misses.value.ui64 =
	wmsum_value(&arc_sums.arcstat_prefetch_data_misses);
	as->arcstat_prefetch_metadata_hits.value.ui64 =
	wmsum_value(&arc_sums.arcstat_prefetch_metadata_hits);
	as->arcstat_prefetch_metadata_misses.value.ui64 =
	wmsum_value(&arc_sums.arcstat_prefetch_metadata_misses);
	as->arcstat_mru_hits.value.ui64 =
	wmsum_value(&arc_sums.arcstat_mru_hits);
	as->arcstat_mru_ghost_hits.value.ui64 =
	wmsum_value(&arc_sums.arcstat_mru_ghost_hits);
	as->arcstat_mfu_hits.value.ui64 =
	wmsum_value(&arc_sums.arcstat_mfu_hits);
	as->arcstat_mfu_ghost_hits.value.ui64 =
	wmsum_value(&arc_sums.arcstat_mfu_ghost_hits);
	as->arcstat_deleted.value.ui64 =
	wmsum_value(&arc_sums.arcstat_deleted);
	as->arcstat_mutex_miss.value.ui64 =
	wmsum_value(&arc_sums.arcstat_mutex_miss);
	as->arcstat_access_skip.value.ui64 =
	wmsum_value(&arc_sums.arcstat_access_skip);
	as->arcstat_evict_skip.value.ui64 =
	wmsum_value(&arc_sums.arcstat_evict_skip);
	as->arcstat_evict_not_enough.value.ui64 =
	wmsum_value(&arc_sums.arcstat_evict_not_enough);
	as->arcstat_evict_l2_cached.value.ui64 =
	wmsum_value(&arc_sums.arcstat_evict_l2_cached);
	as->arcstat_evict_l2_eligible.value.ui64 =
	wmsum_value(&arc_sums.arcstat_evict_l2_eligible);
	as->arcstat_evict_l2_eligible_mfu.value.ui64 =
	wmsum_value(&arc_sums.arcstat_evict_l2_eligible_mfu);
	as->arcstat_evict_l2_eligible_mru.value.ui64 =
	wmsum_value(&arc_sums.arcstat_evict_l2_eligible_mru);
	as->arcstat_evict_l2_ineligible.value.ui64 =
	wmsum_value(&arc_sums.arcstat_evict_l2_ineligible);
	as->arcstat_evict_l2_skip.value.ui64 =
	wmsum_value(&arc_sums.arcstat_evict_l2_skip);
	as->arcstat_hash_collisions.value.ui64 =
	wmsum_value(&arc_sums.arcstat_hash_collisions);
	as->arcstat_hash_chains.value.ui64 =
	wmsum_value(&arc_sums.arcstat_hash_chains);
	as->arcstat_size.value.ui64 =
	aggsum_value(&arc_sums.arcstat_size);
	as->arcstat_compressed_size.value.ui64 =
	wmsum_value(&arc_sums.arcstat_compressed_size);
	as->arcstat_uncompressed_size.value.ui64 =
	wmsum_value(&arc_sums.arcstat_uncompressed_size);
	as->arcstat_overhead_size.value.ui64 =
	wmsum_value(&arc_sums.arcstat_overhead_size);
	as->arcstat_hdr_size.value.ui64 =
	wmsum_value(&arc_sums.arcstat_hdr_size);
	as->arcstat_data_size.value.ui64 =
	wmsum_value(&arc_sums.arcstat_data_size);
	as->arcstat_metadata_size.value.ui64 =
	wmsum_value(&arc_sums.arcstat_metadata_size);
	as->arcstat_dbuf_size.value.ui64 =
	wmsum_value(&arc_sums.arcstat_dbuf_size);
	#if defined(COMPAT_FREEBSD11)
	as->arcstat_other_size.value.ui64 =
	wmsum_value(&arc_sums.arcstat_bonus_size) +
	aggsum_value(&arc_sums.arcstat_dnode_size) +
	wmsum_value(&arc_sums.arcstat_dbuf_size);
	#endif

	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);

	as->arcstat_dnode_size.value.ui64 =
	aggsum_value(&arc_sums.arcstat_dnode_size);
	as->arcstat_bonus_size.value.ui64 =
	wmsum_value(&arc_sums.arcstat_bonus_size);
	as->arcstat_l2_hits.value.ui64 =
	wmsum_value(&arc_sums.arcstat_l2_hits);
	as->arcstat_l2_misses.value.ui64 =
	wmsum_value(&arc_sums.arcstat_l2_misses);
	as->arcstat_l2_prefetch_asize.value.ui64 =
	wmsum_value(&arc_sums.arcstat_l2_prefetch_asize);
	as->arcstat_l2_mru_asize.value.ui64 =
	wmsum_value(&arc_sums.arcstat_l2_mru_asize);
	as->arcstat_l2_mfu_asize.value.ui64 =
	wmsum_value(&arc_sums.arcstat_l2_mfu_asize);
	as->arcstat_l2_bufc_data_asize.value.ui64 =
	wmsum_value(&arc_sums.arcstat_l2_bufc_data_asize);
	as->arcstat_l2_bufc_metadata_asize.value.ui64 =
	wmsum_value(&arc_sums.arcstat_l2_bufc_metadata_asize);
	as->arcstat_l2_feeds.value.ui64 =
	wmsum_value(&arc_sums.arcstat_l2_feeds);
	as->arcstat_l2_rw_clash.value.ui64 =
	wmsum_value(&arc_sums.arcstat_l2_rw_clash);
	as->arcstat_l2_read_bytes.value.ui64 =
	wmsum_value(&arc_sums.arcstat_l2_read_bytes);
	as->arcstat_l2_write_bytes.value.ui64 =
	wmsum_value(&arc_sums.arcstat_l2_write_bytes);
	as->arcstat_l2_writes_sent.value.ui64 =
	wmsum_value(&arc_sums.arcstat_l2_writes_sent);
	as->arcstat_l2_writes_done.value.ui64 =
	wmsum_value(&arc_sums.arcstat_l2_writes_done);
	as->arcstat_l2_writes_error.value.ui64 =
	wmsum_value(&arc_sums.arcstat_l2_writes_error);
	as->arcstat_l2_writes_lock_retry.value.ui64 =
	wmsum_value(&arc_sums.arcstat_l2_writes_lock_retry);
	as->arcstat_l2_evict_lock_retry.value.ui64 =
	wmsum_value(&arc_sums.arcstat_l2_evict_lock_retry);
	as->arcstat_l2_evict_reading.value.ui64 =
	wmsum_value(&arc_sums.arcstat_l2_evict_reading);
	as->arcstat_l2_evict_l1cached.value.ui64 =
	wmsum_value(&arc_sums.arcstat_l2_evict_l1cached);
	as->arcstat_l2_free_on_write.value.ui64 =
	wmsum_value(&arc_sums.arcstat_l2_free_on_write);
	as->arcstat_l2_abort_lowmem.value.ui64 =
	wmsum_value(&arc_sums.arcstat_l2_abort_lowmem);
	as->arcstat_l2_cksum_bad.value.ui64 =
	wmsum_value(&arc_sums.arcstat_l2_cksum_bad);
	as->arcstat_l2_io_error.value.ui64 =
	wmsum_value(&arc_sums.arcstat_l2_io_error);
	as->arcstat_l2_lsize.value.ui64 =
	wmsum_value(&arc_sums.arcstat_l2_lsize);
	as->arcstat_l2_psize.value.ui64 =
	wmsum_value(&arc_sums.arcstat_l2_psize);
	as->arcstat_l2_hdr_size.value.ui64 =
	aggsum_value(&arc_sums.arcstat_l2_hdr_size);
	as->arcstat_l2_log_blk_writes.value.ui64 =
	wmsum_value(&arc_sums.arcstat_l2_log_blk_writes);
	as->arcstat_l2_log_blk_asize.value.ui64 =
	wmsum_value(&arc_sums.arcstat_l2_log_blk_asize);
	as->arcstat_l2_log_blk_count.value.ui64 =
	wmsum_value(&arc_sums.arcstat_l2_log_blk_count);
	as->arcstat_l2_rebuild_success.value.ui64 =
	wmsum_value(&arc_sums.arcstat_l2_rebuild_success);
	as->arcstat_l2_rebuild_abort_unsupported.value.ui64 =
	wmsum_value(&arc_sums.arcstat_l2_rebuild_abort_unsupported);
	as->arcstat_l2_rebuild_abort_io_errors.value.ui64 =
	wmsum_value(&arc_sums.arcstat_l2_rebuild_abort_io_errors);
	as->arcstat_l2_rebuild_abort_dh_errors.value.ui64 =
	wmsum_value(&arc_sums.arcstat_l2_rebuild_abort_dh_errors);
	as->arcstat_l2_rebuild_abort_cksum_lb_errors.value.ui64 =
	wmsum_value(&arc_sums.arcstat_l2_rebuild_abort_cksum_lb_errors);
	as->arcstat_l2_rebuild_abort_lowmem.value.ui64 =
	wmsum_value(&arc_sums.arcstat_l2_rebuild_abort_lowmem);
	as->arcstat_l2_rebuild_size.value.ui64 =
	wmsum_value(&arc_sums.arcstat_l2_rebuild_size);
	as->arcstat_l2_rebuild_asize.value.ui64 =
	wmsum_value(&arc_sums.arcstat_l2_rebuild_asize);
	as->arcstat_l2_rebuild_bufs.value.ui64 =
	wmsum_value(&arc_sums.arcstat_l2_rebuild_bufs);
	as->arcstat_l2_rebuild_bufs_precached.value.ui64 =
	wmsum_value(&arc_sums.arcstat_l2_rebuild_bufs_precached);
	as->arcstat_l2_rebuild_log_blks.value.ui64 =
	wmsum_value(&arc_sums.arcstat_l2_rebuild_log_blks);
	as->arcstat_memory_throttle_count.value.ui64 =
	wmsum_value(&arc_sums.arcstat_memory_throttle_count);
	as->arcstat_memory_direct_count.value.ui64 =
	wmsum_value(&arc_sums.arcstat_memory_direct_count);
	as->arcstat_memory_indirect_count.value.ui64 =
	wmsum_value(&arc_sums.arcstat_memory_indirect_count);

	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();

	as->arcstat_prune.value.ui64 =
	wmsum_value(&arc_sums.arcstat_prune);
	as->arcstat_meta_used.value.ui64 =
	aggsum_value(&arc_sums.arcstat_meta_used);
	as->arcstat_async_upgrade_sync.value.ui64 =
	wmsum_value(&arc_sums.arcstat_async_upgrade_sync);
	as->arcstat_demand_hit_predictive_prefetch.value.ui64 =
	wmsum_value(&arc_sums.arcstat_demand_hit_predictive_prefetch);
	as->arcstat_demand_hit_prescient_prefetch.value.ui64 =
	wmsum_value(&arc_sums.arcstat_demand_hit_prescient_prefetch);
	as->arcstat_raw_size.value.ui64 =
	wmsum_value(&arc_sums.arcstat_raw_size);
	as->arcstat_cached_only_in_progress.value.ui64 =
	wmsum_value(&arc_sums.arcstat_cached_only_in_progress);
	as->arcstat_abd_chunk_waste_size.value.ui64 =
	wmsum_value(&arc_sums.arcstat_abd_chunk_waste_size);

	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. In this context full 64bit
	* division would be a waste of time, so limit it to 32 bits.
	*/
	return ((unsigned int)buf_hash(hdr->b_spa, &hdr->b_dva, hdr->b_birth) %
	multilist_get_num_sublists(ml));
	}

	static unsigned int
	arc_state_l2c_multilist_index_func(multilist_t ml, void obj)
	{
	panic("Header %p insert into arc_l2c_only %p", obj, 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 >= MIN_ARC_MAX) && (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)
	{
	multilist_create(&arc_mru->arcs_list[ARC_BUFC_METADATA],
	sizeof (arc_buf_hdr_t),
	offsetof(arc_buf_hdr_t, b_l1hdr.b_arc_node),
	arc_state_multilist_index_func);
	multilist_create(&arc_mru->arcs_list[ARC_BUFC_DATA],
	sizeof (arc_buf_hdr_t),
	offsetof(arc_buf_hdr_t, b_l1hdr.b_arc_node),
	arc_state_multilist_index_func);
	multilist_create(&arc_mru_ghost->arcs_list[ARC_BUFC_METADATA],
	sizeof (arc_buf_hdr_t),
	offsetof(arc_buf_hdr_t, b_l1hdr.b_arc_node),
	arc_state_multilist_index_func);
	multilist_create(&arc_mru_ghost->arcs_list[ARC_BUFC_DATA],
	sizeof (arc_buf_hdr_t),
	offsetof(arc_buf_hdr_t, b_l1hdr.b_arc_node),
	arc_state_multilist_index_func);
	multilist_create(&arc_mfu->arcs_list[ARC_BUFC_METADATA],
	sizeof (arc_buf_hdr_t),
	offsetof(arc_buf_hdr_t, b_l1hdr.b_arc_node),
	arc_state_multilist_index_func);
	multilist_create(&arc_mfu->arcs_list[ARC_BUFC_DATA],
	sizeof (arc_buf_hdr_t),
	offsetof(arc_buf_hdr_t, b_l1hdr.b_arc_node),
	arc_state_multilist_index_func);
	multilist_create(&arc_mfu_ghost->arcs_list[ARC_BUFC_METADATA],
	sizeof (arc_buf_hdr_t),
	offsetof(arc_buf_hdr_t, b_l1hdr.b_arc_node),
	arc_state_multilist_index_func);
	multilist_create(&arc_mfu_ghost->arcs_list[ARC_BUFC_DATA],
	sizeof (arc_buf_hdr_t),
	offsetof(arc_buf_hdr_t, b_l1hdr.b_arc_node),
	arc_state_multilist_index_func);
	/*
	* L2 headers should never be on the L2 state list since they don't
	* have L1 headers allocated. Special index function asserts that.
	*/
	multilist_create(&arc_l2c_only->arcs_list[ARC_BUFC_METADATA],
	sizeof (arc_buf_hdr_t),
	offsetof(arc_buf_hdr_t, b_l1hdr.b_arc_node),
	arc_state_l2c_multilist_index_func);
	multilist_create(&arc_l2c_only->arcs_list[ARC_BUFC_DATA],
	sizeof (arc_buf_hdr_t),
	offsetof(arc_buf_hdr_t, b_l1hdr.b_arc_node),
	arc_state_l2c_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);

	wmsum_init(&arc_sums.arcstat_hits, 0);
	wmsum_init(&arc_sums.arcstat_misses, 0);
	wmsum_init(&arc_sums.arcstat_demand_data_hits, 0);
	wmsum_init(&arc_sums.arcstat_demand_data_misses, 0);
	wmsum_init(&arc_sums.arcstat_demand_metadata_hits, 0);
	wmsum_init(&arc_sums.arcstat_demand_metadata_misses, 0);
	wmsum_init(&arc_sums.arcstat_prefetch_data_hits, 0);
	wmsum_init(&arc_sums.arcstat_prefetch_data_misses, 0);
	wmsum_init(&arc_sums.arcstat_prefetch_metadata_hits, 0);
	wmsum_init(&arc_sums.arcstat_prefetch_metadata_misses, 0);
	wmsum_init(&arc_sums.arcstat_mru_hits, 0);
	wmsum_init(&arc_sums.arcstat_mru_ghost_hits, 0);
	wmsum_init(&arc_sums.arcstat_mfu_hits, 0);
	wmsum_init(&arc_sums.arcstat_mfu_ghost_hits, 0);
	wmsum_init(&arc_sums.arcstat_deleted, 0);
	wmsum_init(&arc_sums.arcstat_mutex_miss, 0);
	wmsum_init(&arc_sums.arcstat_access_skip, 0);
	wmsum_init(&arc_sums.arcstat_evict_skip, 0);
	wmsum_init(&arc_sums.arcstat_evict_not_enough, 0);
	wmsum_init(&arc_sums.arcstat_evict_l2_cached, 0);
	wmsum_init(&arc_sums.arcstat_evict_l2_eligible, 0);
	wmsum_init(&arc_sums.arcstat_evict_l2_eligible_mfu, 0);
	wmsum_init(&arc_sums.arcstat_evict_l2_eligible_mru, 0);
	wmsum_init(&arc_sums.arcstat_evict_l2_ineligible, 0);
	wmsum_init(&arc_sums.arcstat_evict_l2_skip, 0);
	wmsum_init(&arc_sums.arcstat_hash_collisions, 0);
	wmsum_init(&arc_sums.arcstat_hash_chains, 0);
	aggsum_init(&arc_sums.arcstat_size, 0);
	wmsum_init(&arc_sums.arcstat_compressed_size, 0);
	wmsum_init(&arc_sums.arcstat_uncompressed_size, 0);
	wmsum_init(&arc_sums.arcstat_overhead_size, 0);
	wmsum_init(&arc_sums.arcstat_hdr_size, 0);
	wmsum_init(&arc_sums.arcstat_data_size, 0);
	wmsum_init(&arc_sums.arcstat_metadata_size, 0);
	wmsum_init(&arc_sums.arcstat_dbuf_size, 0);
	aggsum_init(&arc_sums.arcstat_dnode_size, 0);
	wmsum_init(&arc_sums.arcstat_bonus_size, 0);
	wmsum_init(&arc_sums.arcstat_l2_hits, 0);
	wmsum_init(&arc_sums.arcstat_l2_misses, 0);
	wmsum_init(&arc_sums.arcstat_l2_prefetch_asize, 0);
	wmsum_init(&arc_sums.arcstat_l2_mru_asize, 0);
	wmsum_init(&arc_sums.arcstat_l2_mfu_asize, 0);
	wmsum_init(&arc_sums.arcstat_l2_bufc_data_asize, 0);
	wmsum_init(&arc_sums.arcstat_l2_bufc_metadata_asize, 0);
	wmsum_init(&arc_sums.arcstat_l2_feeds, 0);
	wmsum_init(&arc_sums.arcstat_l2_rw_clash, 0);
	wmsum_init(&arc_sums.arcstat_l2_read_bytes, 0);
	wmsum_init(&arc_sums.arcstat_l2_write_bytes, 0);
	wmsum_init(&arc_sums.arcstat_l2_writes_sent, 0);
	wmsum_init(&arc_sums.arcstat_l2_writes_done, 0);
	wmsum_init(&arc_sums.arcstat_l2_writes_error, 0);
	wmsum_init(&arc_sums.arcstat_l2_writes_lock_retry, 0);
	wmsum_init(&arc_sums.arcstat_l2_evict_lock_retry, 0);
	wmsum_init(&arc_sums.arcstat_l2_evict_reading, 0);
	wmsum_init(&arc_sums.arcstat_l2_evict_l1cached, 0);
	wmsum_init(&arc_sums.arcstat_l2_free_on_write, 0);
	wmsum_init(&arc_sums.arcstat_l2_abort_lowmem, 0);
	wmsum_init(&arc_sums.arcstat_l2_cksum_bad, 0);
	wmsum_init(&arc_sums.arcstat_l2_io_error, 0);
	wmsum_init(&arc_sums.arcstat_l2_lsize, 0);
	wmsum_init(&arc_sums.arcstat_l2_psize, 0);
	aggsum_init(&arc_sums.arcstat_l2_hdr_size, 0);
	wmsum_init(&arc_sums.arcstat_l2_log_blk_writes, 0);
	wmsum_init(&arc_sums.arcstat_l2_log_blk_asize, 0);
	wmsum_init(&arc_sums.arcstat_l2_log_blk_count, 0);
	wmsum_init(&arc_sums.arcstat_l2_rebuild_success, 0);
	wmsum_init(&arc_sums.arcstat_l2_rebuild_abort_unsupported, 0);
	wmsum_init(&arc_sums.arcstat_l2_rebuild_abort_io_errors, 0);
	wmsum_init(&arc_sums.arcstat_l2_rebuild_abort_dh_errors, 0);
	wmsum_init(&arc_sums.arcstat_l2_rebuild_abort_cksum_lb_errors, 0);
	wmsum_init(&arc_sums.arcstat_l2_rebuild_abort_lowmem, 0);
	wmsum_init(&arc_sums.arcstat_l2_rebuild_size, 0);
	wmsum_init(&arc_sums.arcstat_l2_rebuild_asize, 0);
	wmsum_init(&arc_sums.arcstat_l2_rebuild_bufs, 0);
	wmsum_init(&arc_sums.arcstat_l2_rebuild_bufs_precached, 0);
	wmsum_init(&arc_sums.arcstat_l2_rebuild_log_blks, 0);
	wmsum_init(&arc_sums.arcstat_memory_throttle_count, 0);
	wmsum_init(&arc_sums.arcstat_memory_direct_count, 0);
	wmsum_init(&arc_sums.arcstat_memory_indirect_count, 0);
	wmsum_init(&arc_sums.arcstat_prune, 0);
	aggsum_init(&arc_sums.arcstat_meta_used, 0);
	wmsum_init(&arc_sums.arcstat_async_upgrade_sync, 0);
	wmsum_init(&arc_sums.arcstat_demand_hit_predictive_prefetch, 0);
	wmsum_init(&arc_sums.arcstat_demand_hit_prescient_prefetch, 0);
	wmsum_init(&arc_sums.arcstat_raw_size, 0);
	wmsum_init(&arc_sums.arcstat_cached_only_in_progress, 0);
	wmsum_init(&arc_sums.arcstat_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]);

	wmsum_fini(&arc_sums.arcstat_hits);
	wmsum_fini(&arc_sums.arcstat_misses);
	wmsum_fini(&arc_sums.arcstat_demand_data_hits);
	wmsum_fini(&arc_sums.arcstat_demand_data_misses);
	wmsum_fini(&arc_sums.arcstat_demand_metadata_hits);
	wmsum_fini(&arc_sums.arcstat_demand_metadata_misses);
	wmsum_fini(&arc_sums.arcstat_prefetch_data_hits);
	wmsum_fini(&arc_sums.arcstat_prefetch_data_misses);
	wmsum_fini(&arc_sums.arcstat_prefetch_metadata_hits);
	wmsum_fini(&arc_sums.arcstat_prefetch_metadata_misses);
	wmsum_fini(&arc_sums.arcstat_mru_hits);
	wmsum_fini(&arc_sums.arcstat_mru_ghost_hits);
	wmsum_fini(&arc_sums.arcstat_mfu_hits);
	wmsum_fini(&arc_sums.arcstat_mfu_ghost_hits);
	wmsum_fini(&arc_sums.arcstat_deleted);
	wmsum_fini(&arc_sums.arcstat_mutex_miss);
	wmsum_fini(&arc_sums.arcstat_access_skip);
	wmsum_fini(&arc_sums.arcstat_evict_skip);
	wmsum_fini(&arc_sums.arcstat_evict_not_enough);
	wmsum_fini(&arc_sums.arcstat_evict_l2_cached);
	wmsum_fini(&arc_sums.arcstat_evict_l2_eligible);
	wmsum_fini(&arc_sums.arcstat_evict_l2_eligible_mfu);
	wmsum_fini(&arc_sums.arcstat_evict_l2_eligible_mru);
	wmsum_fini(&arc_sums.arcstat_evict_l2_ineligible);
	wmsum_fini(&arc_sums.arcstat_evict_l2_skip);
	wmsum_fini(&arc_sums.arcstat_hash_collisions);
	wmsum_fini(&arc_sums.arcstat_hash_chains);
	aggsum_fini(&arc_sums.arcstat_size);
	wmsum_fini(&arc_sums.arcstat_compressed_size);
	wmsum_fini(&arc_sums.arcstat_uncompressed_size);
	wmsum_fini(&arc_sums.arcstat_overhead_size);
	wmsum_fini(&arc_sums.arcstat_hdr_size);
	wmsum_fini(&arc_sums.arcstat_data_size);
	wmsum_fini(&arc_sums.arcstat_metadata_size);
	wmsum_fini(&arc_sums.arcstat_dbuf_size);
	aggsum_fini(&arc_sums.arcstat_dnode_size);
	wmsum_fini(&arc_sums.arcstat_bonus_size);
	wmsum_fini(&arc_sums.arcstat_l2_hits);
	wmsum_fini(&arc_sums.arcstat_l2_misses);
	wmsum_fini(&arc_sums.arcstat_l2_prefetch_asize);
	wmsum_fini(&arc_sums.arcstat_l2_mru_asize);
	wmsum_fini(&arc_sums.arcstat_l2_mfu_asize);
	wmsum_fini(&arc_sums.arcstat_l2_bufc_data_asize);
	wmsum_fini(&arc_sums.arcstat_l2_bufc_metadata_asize);
	wmsum_fini(&arc_sums.arcstat_l2_feeds);
	wmsum_fini(&arc_sums.arcstat_l2_rw_clash);
	wmsum_fini(&arc_sums.arcstat_l2_read_bytes);
	wmsum_fini(&arc_sums.arcstat_l2_write_bytes);
	wmsum_fini(&arc_sums.arcstat_l2_writes_sent);
	wmsum_fini(&arc_sums.arcstat_l2_writes_done);
	wmsum_fini(&arc_sums.arcstat_l2_writes_error);
	wmsum_fini(&arc_sums.arcstat_l2_writes_lock_retry);
	wmsum_fini(&arc_sums.arcstat_l2_evict_lock_retry);
	wmsum_fini(&arc_sums.arcstat_l2_evict_reading);
	wmsum_fini(&arc_sums.arcstat_l2_evict_l1cached);
	wmsum_fini(&arc_sums.arcstat_l2_free_on_write);
	wmsum_fini(&arc_sums.arcstat_l2_abort_lowmem);
	wmsum_fini(&arc_sums.arcstat_l2_cksum_bad);
	wmsum_fini(&arc_sums.arcstat_l2_io_error);
	wmsum_fini(&arc_sums.arcstat_l2_lsize);
	wmsum_fini(&arc_sums.arcstat_l2_psize);
	aggsum_fini(&arc_sums.arcstat_l2_hdr_size);
	wmsum_fini(&arc_sums.arcstat_l2_log_blk_writes);
	wmsum_fini(&arc_sums.arcstat_l2_log_blk_asize);
	wmsum_fini(&arc_sums.arcstat_l2_log_blk_count);
	wmsum_fini(&arc_sums.arcstat_l2_rebuild_success);
	wmsum_fini(&arc_sums.arcstat_l2_rebuild_abort_unsupported);
	wmsum_fini(&arc_sums.arcstat_l2_rebuild_abort_io_errors);
	wmsum_fini(&arc_sums.arcstat_l2_rebuild_abort_dh_errors);
	wmsum_fini(&arc_sums.arcstat_l2_rebuild_abort_cksum_lb_errors);
	wmsum_fini(&arc_sums.arcstat_l2_rebuild_abort_lowmem);
	wmsum_fini(&arc_sums.arcstat_l2_rebuild_size);
	wmsum_fini(&arc_sums.arcstat_l2_rebuild_asize);
	wmsum_fini(&arc_sums.arcstat_l2_rebuild_bufs);
	wmsum_fini(&arc_sums.arcstat_l2_rebuild_bufs_precached);
	wmsum_fini(&arc_sums.arcstat_l2_rebuild_log_blks);
	wmsum_fini(&arc_sums.arcstat_memory_throttle_count);
	wmsum_fini(&arc_sums.arcstat_memory_direct_count);
	wmsum_fini(&arc_sums.arcstat_memory_indirect_count);
	wmsum_fini(&arc_sums.arcstat_prune);
	aggsum_fini(&arc_sums.arcstat_meta_used);
	wmsum_fini(&arc_sums.arcstat_async_upgrade_sync);
	wmsum_fini(&arc_sums.arcstat_demand_hit_predictive_prefetch);
	wmsum_fini(&arc_sums.arcstat_demand_hit_prescient_prefetch);
	wmsum_fini(&arc_sums.arcstat_raw_size);
	wmsum_fini(&arc_sums.arcstat_cached_only_in_progress);
	wmsum_fini(&arc_sums.arcstat_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);

	#ifdef _KERNEL
	/*
	* If zfs_arc_max is non-zero at init, meaning it was set in the kernel
	* environment before the module was loaded, don't block setting the
	* maximum because it is less than arc_c_min, instead, reset arc_c_min
	* to a lower value.
	* zfs_arc_min will be handled by arc_tuning_update().
	*/
	if (zfs_arc_max != 0 && zfs_arc_max >= MIN_ARC_MAX &&
	zfs_arc_max < allmem) {
	arc_c_max = zfs_arc_max;
	if (arc_c_min >= arc_c_max) {
	arc_c_min = MAX(zfs_arc_max / 2,
	2ULL << SPA_MAXBLOCKSHIFT);
	}
	}
	#else
	/*
	* 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;
	/*
	* 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, defclsyspri);
	arc_reap_zthr = zthr_create_timer("arc_reap",
	arc_reap_cb_check, arc_reap_cb, NULL, SEC2NSEC(1), minclsyspri);

	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);
	}
	}

	ARCSTAT_BUMP(arcstat_l2_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,
	ARC_HDR_DO_ADAPT \| ARC_HDR_USE_RESERVE);

	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,
	ARC_HDR_DO_ADAPT \| ARC_HDR_USE_RESERVE);
	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(&arc_sums.arcstat_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);
	}

	static void
	l2arc_rebuild_dev(l2arc_dev_t *dev, boolean_t reopen)
	{
	l2arc_dev_hdr_phys_t *l2dhdr = dev->l2ad_dev_hdr;
	uint64_t l2dhdr_asize = dev->l2ad_dev_hdr_asize;
	spa_t *spa = dev->l2ad_spa;

	/*
	* 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);
	}
	}
	}

	/*
	* 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);

	/*
	* Decide if dev is eligible for L2ARC rebuild or whole device
	* trimming. This has to happen before the device is added in the
	* cache device list and l2arc_dev_mtx is released. Otherwise
	* l2arc_feed_thread() might already start writing on the
	* device.
	*/
	l2arc_rebuild_dev(adddev, B_FALSE);

	/*
	* 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 a vdev is eligible for L2ARC rebuild, called from vdev_reopen()
	* in case of onlining a cache device.
	*/
	void
	l2arc_rebuild_vdev(vdev_t *vd, boolean_t reopen)
	{
	l2arc_dev_t *dev = NULL;

	dev = l2arc_vdev_get(vd);
	ASSERT3P(dev, !=, NULL);

	/*
	* In contrast to l2arc_add_vdev() we do not have to worry about
	* l2arc_feed_thread() invalidating previous content when onlining a
	* cache device. The device parameters (l2ad*) are not cleared when
	* offlining the device and writing new buffers will not invalidate
	* all previous content. In worst case only buffers that have not had
	* their log block written to the device will be lost.
	* When onlining the cache device (ie offline->online without exporting
	* the pool in between) this happens:
	* vdev_reopen() -> vdev_open() -> l2arc_rebuild_vdev()
	* \| \|
	* vdev_is_dead() = B_FALSE l2ad_rebuild = B_TRUE
	* During the time where vdev_is_dead = B_FALSE and until l2ad_rebuild
	* is set to B_TRUE we might write additional buffers to the device.
	*/
	l2arc_rebuild_dev(dev, reopen);
	}

	/*
	* 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;

	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",
	(u_longlong_t)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,
	(u_longlong_t)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,
	(u_longlong_t)this_lbp->lbp_daddr,
	(u_longlong_t)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",
	(u_longlong_t)this_lbp->lbp_daddr,
	(u_longlong_t)dev->l2ad_vdev->vdev_guid,
	(u_longlong_t)dev->l2ad_hand,
	(u_longlong_t)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,
	(u_longlong_t)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_min,
	param_get_long, ZMOD_RW, "Min arc size");

	ZFS_MODULE_PARAM_CALL(zfs_arc, zfs_arc_, max, param_set_arc_max,
	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.c b/sys/contrib/openzfs/module/zfs/dmu.c
	index 1c47430953b1..8302d506146f 100644
	--- a/sys/contrib/openzfs/module/zfs/dmu.c
	+++ b/sys/contrib/openzfs/module/zfs/dmu.c
	@@ -1,2359 +1,2358 @@
	/*
	* 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) 2013 by Saso Kiselkov. All rights reserved.
	* Copyright (c) 2013, Joyent, Inc. All rights reserved.
	* Copyright (c) 2016, Nexenta Systems, Inc. All rights reserved.
	* Copyright (c) 2015 by Chunwei Chen. All rights reserved.
	* Copyright (c) 2019 Datto Inc.
	* Copyright (c) 2019, Klara Inc.
	* Copyright (c) 2019, Allan Jude
	*/

	#include <sys/dmu.h>
	#include <sys/dmu_impl.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/dsl_prop.h>
	#include <sys/dmu_zfetch.h>
	#include <sys/zfs_ioctl.h>
	#include <sys/zap.h>
	#include <sys/zio_checksum.h>
	#include <sys/zio_compress.h>
	#include <sys/sa.h>
	#include <sys/zfeature.h>
	#include <sys/abd.h>
	#include <sys/trace_zfs.h>
	#include <sys/zfs_racct.h>
	#include <sys/zfs_rlock.h>
	#ifdef _KERNEL
	#include <sys/vmsystm.h>
	#include <sys/zfs_znode.h>
	#endif

	/*
	* Enable/disable nopwrite feature.
	*/
	int zfs_nopwrite_enabled = 1;

	/*
	* Tunable to control percentage of dirtied L1 blocks from frees allowed into
	* one TXG. After this threshold is crossed, additional dirty blocks from frees
	* will wait until the next TXG.
	* A value of zero will disable this throttle.
	*/
	unsigned long zfs_per_txg_dirty_frees_percent = 5;

	/*
	* Enable/disable forcing txg sync when dirty in dmu_offset_next.
	*/
	int zfs_dmu_offset_next_sync = 0;

	/*
	* Limit the amount we can prefetch with one call to this amount. This
	* helps to limit the amount of memory that can be used by prefetching.
	* Larger objects should be prefetched a bit at a time.
	*/
	int dmu_prefetch_max = 8 * SPA_MAXBLOCKSIZE;

	const dmu_object_type_info_t dmu_ot[DMU_OT_NUMTYPES] = {
	{DMU_BSWAP_UINT8, TRUE, FALSE, FALSE, "unallocated" },
	{DMU_BSWAP_ZAP, TRUE, TRUE, FALSE, "object directory" },
	{DMU_BSWAP_UINT64, TRUE, TRUE, FALSE, "object array" },
	{DMU_BSWAP_UINT8, TRUE, FALSE, FALSE, "packed nvlist" },
	{DMU_BSWAP_UINT64, TRUE, FALSE, FALSE, "packed nvlist size" },
	{DMU_BSWAP_UINT64, TRUE, FALSE, FALSE, "bpobj" },
	{DMU_BSWAP_UINT64, TRUE, FALSE, FALSE, "bpobj header" },
	{DMU_BSWAP_UINT64, TRUE, FALSE, FALSE, "SPA space map header" },
	{DMU_BSWAP_UINT64, TRUE, FALSE, FALSE, "SPA space map" },
	{DMU_BSWAP_UINT64, TRUE, FALSE, TRUE, "ZIL intent log" },
	{DMU_BSWAP_DNODE, TRUE, FALSE, TRUE, "DMU dnode" },
	{DMU_BSWAP_OBJSET, TRUE, TRUE, FALSE, "DMU objset" },
	{DMU_BSWAP_UINT64, TRUE, TRUE, FALSE, "DSL directory" },
	{DMU_BSWAP_ZAP, TRUE, TRUE, FALSE, "DSL directory child map"},
	{DMU_BSWAP_ZAP, TRUE, TRUE, FALSE, "DSL dataset snap map" },
	{DMU_BSWAP_ZAP, TRUE, TRUE, FALSE, "DSL props" },
	{DMU_BSWAP_UINT64, TRUE, TRUE, FALSE, "DSL dataset" },
	{DMU_BSWAP_ZNODE, TRUE, FALSE, FALSE, "ZFS znode" },
	{DMU_BSWAP_OLDACL, TRUE, FALSE, TRUE, "ZFS V0 ACL" },
	{DMU_BSWAP_UINT8, FALSE, FALSE, TRUE, "ZFS plain file" },
	{DMU_BSWAP_ZAP, TRUE, FALSE, TRUE, "ZFS directory" },
	{DMU_BSWAP_ZAP, TRUE, FALSE, FALSE, "ZFS master node" },
	{DMU_BSWAP_ZAP, TRUE, FALSE, TRUE, "ZFS delete queue" },
	{DMU_BSWAP_UINT8, FALSE, FALSE, TRUE, "zvol object" },
	{DMU_BSWAP_ZAP, TRUE, FALSE, FALSE, "zvol prop" },
	{DMU_BSWAP_UINT8, FALSE, FALSE, TRUE, "other uint8[]" },
	{DMU_BSWAP_UINT64, FALSE, FALSE, TRUE, "other uint64[]" },
	{DMU_BSWAP_ZAP, TRUE, FALSE, FALSE, "other ZAP" },
	{DMU_BSWAP_ZAP, TRUE, FALSE, FALSE, "persistent error log" },
	{DMU_BSWAP_UINT8, TRUE, FALSE, FALSE, "SPA history" },
	{DMU_BSWAP_UINT64, TRUE, FALSE, FALSE, "SPA history offsets" },
	{DMU_BSWAP_ZAP, TRUE, TRUE, FALSE, "Pool properties" },
	{DMU_BSWAP_ZAP, TRUE, TRUE, FALSE, "DSL permissions" },
	{DMU_BSWAP_ACL, TRUE, FALSE, TRUE, "ZFS ACL" },
	{DMU_BSWAP_UINT8, TRUE, FALSE, TRUE, "ZFS SYSACL" },
	{DMU_BSWAP_UINT8, TRUE, FALSE, TRUE, "FUID table" },
	{DMU_BSWAP_UINT64, TRUE, FALSE, FALSE, "FUID table size" },
	{DMU_BSWAP_ZAP, TRUE, TRUE, FALSE, "DSL dataset next clones"},
	{DMU_BSWAP_ZAP, TRUE, FALSE, FALSE, "scan work queue" },
	{DMU_BSWAP_ZAP, TRUE, FALSE, TRUE, "ZFS user/group/project used" },
	{DMU_BSWAP_ZAP, TRUE, FALSE, TRUE, "ZFS user/group/project quota"},
	{DMU_BSWAP_ZAP, TRUE, TRUE, FALSE, "snapshot refcount tags"},
	{DMU_BSWAP_ZAP, TRUE, FALSE, FALSE, "DDT ZAP algorithm" },
	{DMU_BSWAP_ZAP, TRUE, FALSE, FALSE, "DDT statistics" },
	{DMU_BSWAP_UINT8, TRUE, FALSE, TRUE, "System attributes" },
	{DMU_BSWAP_ZAP, TRUE, FALSE, TRUE, "SA master node" },
	{DMU_BSWAP_ZAP, TRUE, FALSE, TRUE, "SA attr registration" },
	{DMU_BSWAP_ZAP, TRUE, FALSE, TRUE, "SA attr layouts" },
	{DMU_BSWAP_ZAP, TRUE, FALSE, FALSE, "scan translations" },
	{DMU_BSWAP_UINT8, FALSE, FALSE, TRUE, "deduplicated block" },
	{DMU_BSWAP_ZAP, TRUE, TRUE, FALSE, "DSL deadlist map" },
	{DMU_BSWAP_UINT64, TRUE, TRUE, FALSE, "DSL deadlist map hdr" },
	{DMU_BSWAP_ZAP, TRUE, TRUE, FALSE, "DSL dir clones" },
	{DMU_BSWAP_UINT64, TRUE, FALSE, FALSE, "bpobj subobj" }
	};

	const dmu_object_byteswap_info_t dmu_ot_byteswap[DMU_BSWAP_NUMFUNCS] = {
	{ byteswap_uint8_array, "uint8" },
	{ byteswap_uint16_array, "uint16" },
	{ byteswap_uint32_array, "uint32" },
	{ byteswap_uint64_array, "uint64" },
	{ zap_byteswap, "zap" },
	{ dnode_buf_byteswap, "dnode" },
	{ dmu_objset_byteswap, "objset" },
	{ zfs_znode_byteswap, "znode" },
	{ zfs_oldacl_byteswap, "oldacl" },
	{ zfs_acl_byteswap, "acl" }
	};

	static int
	dmu_buf_hold_noread_by_dnode(dnode_t *dn, uint64_t offset,
	void tag, dmu_buf_t *dbp)
	{
	uint64_t blkid;
	dmu_buf_impl_t *db;

	rw_enter(&dn->dn_struct_rwlock, RW_READER);
	blkid = dbuf_whichblock(dn, 0, offset);
	db = dbuf_hold(dn, blkid, tag);
	rw_exit(&dn->dn_struct_rwlock);

	if (db == NULL) {
	*dbp = NULL;
	return (SET_ERROR(EIO));
	}

	*dbp = &db->db;
	return (0);
	}
	int
	dmu_buf_hold_noread(objset_t *os, uint64_t object, uint64_t offset,
	void tag, dmu_buf_t *dbp)
	{
	dnode_t *dn;
	uint64_t blkid;
	dmu_buf_impl_t *db;
	int err;

	err = dnode_hold(os, object, FTAG, &dn);
	if (err)
	return (err);
	rw_enter(&dn->dn_struct_rwlock, RW_READER);
	blkid = dbuf_whichblock(dn, 0, offset);
	db = dbuf_hold(dn, blkid, tag);
	rw_exit(&dn->dn_struct_rwlock);
	dnode_rele(dn, FTAG);

	if (db == NULL) {
	*dbp = NULL;
	return (SET_ERROR(EIO));
	}

	*dbp = &db->db;
	return (err);
	}

	int
	dmu_buf_hold_by_dnode(dnode_t *dn, uint64_t offset,
	void tag, dmu_buf_t *dbp, int flags)
	{
	int err;
	int db_flags = DB_RF_CANFAIL;

	if (flags & DMU_READ_NO_PREFETCH)
	db_flags \|= DB_RF_NOPREFETCH;
	if (flags & DMU_READ_NO_DECRYPT)
	db_flags \|= DB_RF_NO_DECRYPT;

	err = dmu_buf_hold_noread_by_dnode(dn, offset, tag, dbp);
	if (err == 0) {
	dmu_buf_impl_t db = (dmu_buf_impl_t )(*dbp);
	err = dbuf_read(db, NULL, db_flags);
	if (err != 0) {
	dbuf_rele(db, tag);
	*dbp = NULL;
	}
	}

	return (err);
	}

	int
	dmu_buf_hold(objset_t *os, uint64_t object, uint64_t offset,
	void tag, dmu_buf_t *dbp, int flags)
	{
	int err;
	int db_flags = DB_RF_CANFAIL;

	if (flags & DMU_READ_NO_PREFETCH)
	db_flags \|= DB_RF_NOPREFETCH;
	if (flags & DMU_READ_NO_DECRYPT)
	db_flags \|= DB_RF_NO_DECRYPT;

	err = dmu_buf_hold_noread(os, object, offset, tag, dbp);
	if (err == 0) {
	dmu_buf_impl_t db = (dmu_buf_impl_t )(*dbp);
	err = dbuf_read(db, NULL, db_flags);
	if (err != 0) {
	dbuf_rele(db, tag);
	*dbp = NULL;
	}
	}

	return (err);
	}

	int
	dmu_bonus_max(void)
	{
	return (DN_OLD_MAX_BONUSLEN);
	}

	int
	dmu_set_bonus(dmu_buf_t db_fake, int newsize, dmu_tx_t tx)
	{
	dmu_buf_impl_t db = (dmu_buf_impl_t )db_fake;
	dnode_t *dn;
	int error;

	DB_DNODE_ENTER(db);
	dn = DB_DNODE(db);

	if (dn->dn_bonus != db) {
	error = SET_ERROR(EINVAL);
	} else if (newsize < 0 \|\| newsize > db_fake->db_size) {
	error = SET_ERROR(EINVAL);
	} else {
	dnode_setbonuslen(dn, newsize, tx);
	error = 0;
	}

	DB_DNODE_EXIT(db);
	return (error);
	}

	int
	dmu_set_bonustype(dmu_buf_t db_fake, dmu_object_type_t type, dmu_tx_t tx)
	{
	dmu_buf_impl_t db = (dmu_buf_impl_t )db_fake;
	dnode_t *dn;
	int error;

	DB_DNODE_ENTER(db);
	dn = DB_DNODE(db);

	if (!DMU_OT_IS_VALID(type)) {
	error = SET_ERROR(EINVAL);
	} else if (dn->dn_bonus != db) {
	error = SET_ERROR(EINVAL);
	} else {
	dnode_setbonus_type(dn, type, tx);
	error = 0;
	}

	DB_DNODE_EXIT(db);
	return (error);
	}

	dmu_object_type_t
	dmu_get_bonustype(dmu_buf_t *db_fake)
	{
	dmu_buf_impl_t db = (dmu_buf_impl_t )db_fake;
	dnode_t *dn;
	dmu_object_type_t type;

	DB_DNODE_ENTER(db);
	dn = DB_DNODE(db);
	type = dn->dn_bonustype;
	DB_DNODE_EXIT(db);

	return (type);
	}

	int
	dmu_rm_spill(objset_t os, uint64_t object, dmu_tx_t tx)
	{
	dnode_t *dn;
	int error;

	error = dnode_hold(os, object, FTAG, &dn);
	dbuf_rm_spill(dn, tx);
	rw_enter(&dn->dn_struct_rwlock, RW_WRITER);
	dnode_rm_spill(dn, tx);
	rw_exit(&dn->dn_struct_rwlock);
	dnode_rele(dn, FTAG);
	return (error);
	}

	/*
	* Lookup and hold the bonus buffer for the provided dnode. If the dnode
	* has not yet been allocated a new bonus dbuf a will be allocated.
	* Returns ENOENT, EIO, or 0.
	*/
	int dmu_bonus_hold_by_dnode(dnode_t dn, void tag, dmu_buf_t **dbp,
	uint32_t flags)
	{
	dmu_buf_impl_t *db;
	int error;
	uint32_t db_flags = DB_RF_MUST_SUCCEED;

	if (flags & DMU_READ_NO_PREFETCH)
	db_flags \|= DB_RF_NOPREFETCH;
	if (flags & DMU_READ_NO_DECRYPT)
	db_flags \|= DB_RF_NO_DECRYPT;

	rw_enter(&dn->dn_struct_rwlock, RW_READER);
	if (dn->dn_bonus == NULL) {
	rw_exit(&dn->dn_struct_rwlock);
	rw_enter(&dn->dn_struct_rwlock, RW_WRITER);
	if (dn->dn_bonus == NULL)
	dbuf_create_bonus(dn);
	}
	db = dn->dn_bonus;

	/* as long as the bonus buf is held, the dnode will be held */
	if (zfs_refcount_add(&db->db_holds, tag) == 1) {
	VERIFY(dnode_add_ref(dn, db));
	atomic_inc_32(&dn->dn_dbufs_count);
	}

	/*
	* Wait to drop dn_struct_rwlock until after adding the bonus dbuf's
	* hold and incrementing the dbuf count to ensure that dnode_move() sees
	* a dnode hold for every dbuf.
	*/
	rw_exit(&dn->dn_struct_rwlock);

	error = dbuf_read(db, NULL, db_flags);
	if (error) {
	dnode_evict_bonus(dn);
	dbuf_rele(db, tag);
	*dbp = NULL;
	return (error);
	}

	*dbp = &db->db;
	return (0);
	}

	int
	dmu_bonus_hold(objset_t os, uint64_t object, void tag, dmu_buf_t **dbp)
	{
	dnode_t *dn;
	int error;

	error = dnode_hold(os, object, FTAG, &dn);
	if (error)
	return (error);

	error = dmu_bonus_hold_by_dnode(dn, tag, dbp, DMU_READ_NO_PREFETCH);
	dnode_rele(dn, FTAG);

	return (error);
	}

	/*
	* returns ENOENT, EIO, or 0.
	*
	* This interface will allocate a blank spill dbuf when a spill blk
	* doesn't already exist on the dnode.
	*
	* if you only want to find an already existing spill db, then
	* dmu_spill_hold_existing() should be used.
	*/
	int
	dmu_spill_hold_by_dnode(dnode_t dn, uint32_t flags, void tag, dmu_buf_t **dbp)
	{
	dmu_buf_impl_t *db = NULL;
	int err;

	if ((flags & DB_RF_HAVESTRUCT) == 0)
	rw_enter(&dn->dn_struct_rwlock, RW_READER);

	db = dbuf_hold(dn, DMU_SPILL_BLKID, tag);

	if ((flags & DB_RF_HAVESTRUCT) == 0)
	rw_exit(&dn->dn_struct_rwlock);

	if (db == NULL) {
	*dbp = NULL;
	return (SET_ERROR(EIO));
	}
	err = dbuf_read(db, NULL, flags);
	if (err == 0)
	*dbp = &db->db;
	else {
	dbuf_rele(db, tag);
	*dbp = NULL;
	}
	return (err);
	}

	int
	dmu_spill_hold_existing(dmu_buf_t bonus, void tag, dmu_buf_t **dbp)
	{
	dmu_buf_impl_t db = (dmu_buf_impl_t )bonus;
	dnode_t *dn;
	int err;

	DB_DNODE_ENTER(db);
	dn = DB_DNODE(db);

	if (spa_version(dn->dn_objset->os_spa) < SPA_VERSION_SA) {
	err = SET_ERROR(EINVAL);
	} else {
	rw_enter(&dn->dn_struct_rwlock, RW_READER);

	if (!dn->dn_have_spill) {
	err = SET_ERROR(ENOENT);
	} else {
	err = dmu_spill_hold_by_dnode(dn,
	DB_RF_HAVESTRUCT \| DB_RF_CANFAIL, tag, dbp);
	}

	rw_exit(&dn->dn_struct_rwlock);
	}

	DB_DNODE_EXIT(db);
	return (err);
	}

	int
	dmu_spill_hold_by_bonus(dmu_buf_t bonus, uint32_t flags, void tag,
	dmu_buf_t **dbp)
	{
	dmu_buf_impl_t db = (dmu_buf_impl_t )bonus;
	dnode_t *dn;
	int err;
	uint32_t db_flags = DB_RF_CANFAIL;

	if (flags & DMU_READ_NO_DECRYPT)
	db_flags \|= DB_RF_NO_DECRYPT;

	DB_DNODE_ENTER(db);
	dn = DB_DNODE(db);
	err = dmu_spill_hold_by_dnode(dn, db_flags, tag, dbp);
	DB_DNODE_EXIT(db);

	return (err);
	}

	/*
	* Note: longer-term, we should modify all of the dmu_buf_*() interfaces
	* to take a held dnode rather than <os, object> -- the lookup is wasteful,
	* and can induce severe lock contention when writing to several files
	* whose dnodes are in the same block.
	*/
	int
	dmu_buf_hold_array_by_dnode(dnode_t *dn, uint64_t offset, uint64_t length,
	boolean_t read, void tag, int numbufsp, dmu_buf_t ***dbpp, uint32_t flags)
	{
	dmu_buf_t **dbp;
	zstream_t *zs = NULL;
	uint64_t blkid, nblks, i;
	uint32_t dbuf_flags;
	int err;
	zio_t *zio = NULL;
	boolean_t missed = B_FALSE;

	ASSERT(length <= DMU_MAX_ACCESS);

	/*
	* Note: We directly notify the prefetch code of this read, so that
	* we can tell it about the multi-block read. dbuf_read() only knows
	* about the one block it is accessing.
	*/
	dbuf_flags = DB_RF_CANFAIL \| DB_RF_NEVERWAIT \| DB_RF_HAVESTRUCT \|
	DB_RF_NOPREFETCH;

	rw_enter(&dn->dn_struct_rwlock, RW_READER);
	if (dn->dn_datablkshift) {
	int blkshift = dn->dn_datablkshift;
	nblks = (P2ROUNDUP(offset + length, 1ULL << blkshift) -
	P2ALIGN(offset, 1ULL << blkshift)) >> blkshift;
	} else {
	if (offset + length > dn->dn_datablksz) {
	zfs_panic_recover("zfs: accessing past end of object "
	"%llx/%llx (size=%u access=%llu+%llu)",
	(longlong_t)dn->dn_objset->
	os_dsl_dataset->ds_object,
	(longlong_t)dn->dn_object, dn->dn_datablksz,
	(longlong_t)offset, (longlong_t)length);
	rw_exit(&dn->dn_struct_rwlock);
	return (SET_ERROR(EIO));
	}
	nblks = 1;
	}
	dbp = kmem_zalloc(sizeof (dmu_buf_t ) nblks, KM_SLEEP);

	if (read)
	zio = zio_root(dn->dn_objset->os_spa, NULL, NULL,
	ZIO_FLAG_CANFAIL);
	blkid = dbuf_whichblock(dn, 0, offset);
	if ((flags & DMU_READ_NO_PREFETCH) == 0 &&
	DNODE_META_IS_CACHEABLE(dn) && length <= zfetch_array_rd_sz) {
	/*
	* Prepare the zfetch before initiating the demand reads, so
	* that if multiple threads block on same indirect block, we
	* base predictions on the original less racy request order.
	*/
	zs = dmu_zfetch_prepare(&dn->dn_zfetch, blkid, nblks,
	read && DNODE_IS_CACHEABLE(dn), B_TRUE);
	}
	for (i = 0; i < nblks; i++) {
	dmu_buf_impl_t *db = dbuf_hold(dn, blkid + i, tag);
	if (db == NULL) {
	if (zs)
	dmu_zfetch_run(zs, missed, B_TRUE);
	rw_exit(&dn->dn_struct_rwlock);
	dmu_buf_rele_array(dbp, nblks, tag);
	if (read)
	zio_nowait(zio);
	return (SET_ERROR(EIO));
	}

	/*
	* Initiate async demand data read.
	* We check the db_state after calling dbuf_read() because
	* (1) dbuf_read() may change the state to CACHED due to a
	* hit in the ARC, and (2) on a cache miss, a child will
	* have been added to "zio" but not yet completed, so the
	* state will not yet be CACHED.
	*/
	if (read) {
	(void) dbuf_read(db, zio, dbuf_flags);
	if (db->db_state != DB_CACHED)
	missed = B_TRUE;
	}
	dbp[i] = &db->db;
	}

	if (!read)
	zfs_racct_write(length, nblks);

	if (zs)
	dmu_zfetch_run(zs, missed, B_TRUE);
	rw_exit(&dn->dn_struct_rwlock);

	if (read) {
	/* wait for async read i/o */
	err = zio_wait(zio);
	if (err) {
	dmu_buf_rele_array(dbp, nblks, tag);
	return (err);
	}

	/* wait for other io to complete */
	for (i = 0; i < nblks; i++) {
	dmu_buf_impl_t db = (dmu_buf_impl_t )dbp[i];
	mutex_enter(&db->db_mtx);
	while (db->db_state == DB_READ \|\|
	db->db_state == DB_FILL)
	cv_wait(&db->db_changed, &db->db_mtx);
	if (db->db_state == DB_UNCACHED)
	err = SET_ERROR(EIO);
	mutex_exit(&db->db_mtx);
	if (err) {
	dmu_buf_rele_array(dbp, nblks, tag);
	return (err);
	}
	}
	}

	*numbufsp = nblks;
	*dbpp = dbp;
	return (0);
	}

	static int
	dmu_buf_hold_array(objset_t *os, uint64_t object, uint64_t offset,
	uint64_t length, int read, void tag, int numbufsp, dmu_buf_t ***dbpp)
	{
	dnode_t *dn;
	int err;

	err = dnode_hold(os, object, FTAG, &dn);
	if (err)
	return (err);

	err = dmu_buf_hold_array_by_dnode(dn, offset, length, read, tag,
	numbufsp, dbpp, DMU_READ_PREFETCH);

	dnode_rele(dn, FTAG);

	return (err);
	}

	int
	dmu_buf_hold_array_by_bonus(dmu_buf_t *db_fake, uint64_t offset,
	uint64_t length, boolean_t read, void tag, int numbufsp,
	dmu_buf_t ***dbpp)
	{
	dmu_buf_impl_t db = (dmu_buf_impl_t )db_fake;
	dnode_t *dn;
	int err;

	DB_DNODE_ENTER(db);
	dn = DB_DNODE(db);
	err = dmu_buf_hold_array_by_dnode(dn, offset, length, read, tag,
	numbufsp, dbpp, DMU_READ_PREFETCH);
	DB_DNODE_EXIT(db);

	return (err);
	}

	void
	dmu_buf_rele_array(dmu_buf_t *dbp_fake, int numbufs, void tag)
	{
	int i;
	dmu_buf_impl_t dbp = (dmu_buf_impl_t )dbp_fake;

	if (numbufs == 0)
	return;

	for (i = 0; i < numbufs; i++) {
	if (dbp[i])
	dbuf_rele(dbp[i], tag);
	}

	kmem_free(dbp, sizeof (dmu_buf_t ) numbufs);
	}

	/*
	* Issue prefetch i/os for the given blocks. If level is greater than 0, the
	* indirect blocks prefetched will be those that point to the blocks containing
	* the data starting at offset, and continuing to offset + len.
	*
	* Note that if the indirect blocks above the blocks being prefetched are not
	* in cache, they will be asynchronously read in.
	*/
	void
	dmu_prefetch(objset_t *os, uint64_t object, int64_t level, uint64_t offset,
	uint64_t len, zio_priority_t pri)
	{
	dnode_t *dn;
	uint64_t blkid;
	int nblks, err;

	if (len == 0) { /* they're interested in the bonus buffer */
	dn = DMU_META_DNODE(os);

	if (object == 0 \|\| object >= DN_MAX_OBJECT)
	return;

	rw_enter(&dn->dn_struct_rwlock, RW_READER);
	blkid = dbuf_whichblock(dn, level,
	object * sizeof (dnode_phys_t));
	dbuf_prefetch(dn, level, blkid, pri, 0);
	rw_exit(&dn->dn_struct_rwlock);
	return;
	}

	/*
	* See comment before the definition of dmu_prefetch_max.
	*/
	len = MIN(len, dmu_prefetch_max);

	/*
	* XXX - Note, if the dnode for the requested object is not
	* already cached, we will do a synchronous read in the
	* dnode_hold() call. The same is true for any indirects.
	*/
	err = dnode_hold(os, object, FTAG, &dn);
	if (err != 0)
	return;

	/*
	* offset + len - 1 is the last byte we want to prefetch for, and offset
	* is the first. Then dbuf_whichblk(dn, level, off + len - 1) is the
	* last block we want to prefetch, and dbuf_whichblock(dn, level,
	* offset) is the first. Then the number we need to prefetch is the
	* last - first + 1.
	*/
	rw_enter(&dn->dn_struct_rwlock, RW_READER);
	if (level > 0 \|\| dn->dn_datablkshift != 0) {
	nblks = dbuf_whichblock(dn, level, offset + len - 1) -
	dbuf_whichblock(dn, level, offset) + 1;
	} else {
	nblks = (offset < dn->dn_datablksz);
	}

	if (nblks != 0) {
	blkid = dbuf_whichblock(dn, level, offset);
	for (int i = 0; i < nblks; i++)
	dbuf_prefetch(dn, level, blkid + i, pri, 0);
	}
	rw_exit(&dn->dn_struct_rwlock);

	dnode_rele(dn, FTAG);
	}

	/*
	* Get the next "chunk" of file data to free. We traverse the file from
	* the end so that the file gets shorter over time (if we crashes in the
	* middle, this will leave us in a better state). We find allocated file
	* data by simply searching the allocated level 1 indirects.
	*
	* On input, *start should be the first offset that does not need to be
	* freed (e.g. "offset + length"). On return, *start will be the first
	* offset that should be freed and l1blks is set to the number of level 1
	* indirect blocks found within the chunk.
	*/
	static int
	get_next_chunk(dnode_t dn, uint64_t start, uint64_t minimum, uint64_t *l1blks)
	{
	uint64_t blks;
	uint64_t maxblks = DMU_MAX_ACCESS >> (dn->dn_indblkshift + 1);
	/* bytes of data covered by a level-1 indirect block */
	uint64_t iblkrange = (uint64_t)dn->dn_datablksz *
	EPB(dn->dn_indblkshift, SPA_BLKPTRSHIFT);

	ASSERT3U(minimum, <=, *start);

	/*
	* Check if we can free the entire range assuming that all of the
	* L1 blocks in this range have data. If we can, we use this
	* worst case value as an estimate so we can avoid having to look
	* at the object's actual data.
	*/
	uint64_t total_l1blks =
	(roundup(start, iblkrange) - (minimum / iblkrange iblkrange)) /
	iblkrange;
	if (total_l1blks <= maxblks) {
	*l1blks = total_l1blks;
	*start = minimum;
	return (0);
	}
	ASSERT(ISP2(iblkrange));

	for (blks = 0; *start > minimum && blks < maxblks; blks++) {
	int err;

	/*
	* dnode_next_offset(BACKWARDS) will find an allocated L1
	* indirect block at or before the input offset. We must
	* decrement *start so that it is at the end of the region
	* to search.
	*/
	(*start)--;

	err = dnode_next_offset(dn,
	DNODE_FIND_BACKWARDS, start, 2, 1, 0);

	/* if there are no indirect blocks before start, we are done */
	if (err == ESRCH) {
	*start = minimum;
	break;
	} else if (err != 0) {
	*l1blks = blks;
	return (err);
	}

	/* set start to the beginning of this L1 indirect */
	start = P2ALIGN(start, iblkrange);
	}
	if (*start < minimum)
	*start = minimum;
	*l1blks = blks;

	return (0);
	}

	/*
	* If this objset is of type OST_ZFS return true if vfs's unmounted flag is set,
	* otherwise return false.
	* Used below in dmu_free_long_range_impl() to enable abort when unmounting
	*/
	/ARGSUSED/
	static boolean_t
	dmu_objset_zfs_unmounting(objset_t *os)
	{
	#ifdef _KERNEL
	if (dmu_objset_type(os) == DMU_OST_ZFS)
	return (zfs_get_vfs_flag_unmounted(os));
	#endif
	return (B_FALSE);
	}

	static int
	dmu_free_long_range_impl(objset_t os, dnode_t dn, uint64_t offset,
	uint64_t length)
	{
	uint64_t object_size;
	int err;
	uint64_t dirty_frees_threshold;
	dsl_pool_t *dp = dmu_objset_pool(os);

	if (dn == NULL)
	return (SET_ERROR(EINVAL));

	object_size = (dn->dn_maxblkid + 1) * dn->dn_datablksz;
	if (offset >= object_size)
	return (0);

	if (zfs_per_txg_dirty_frees_percent <= 100)
	dirty_frees_threshold =
	zfs_per_txg_dirty_frees_percent * zfs_dirty_data_max / 100;
	else
	dirty_frees_threshold = zfs_dirty_data_max / 20;

	if (length == DMU_OBJECT_END \|\| offset + length > object_size)
	length = object_size - offset;

	while (length != 0) {
	uint64_t chunk_end, chunk_begin, chunk_len;
	uint64_t l1blks;
	dmu_tx_t *tx;

	if (dmu_objset_zfs_unmounting(dn->dn_objset))
	return (SET_ERROR(EINTR));

	chunk_end = chunk_begin = offset + length;

	/* move chunk_begin backwards to the beginning of this chunk */
	err = get_next_chunk(dn, &chunk_begin, offset, &l1blks);
	if (err)
	return (err);
	ASSERT3U(chunk_begin, >=, offset);
	ASSERT3U(chunk_begin, <=, chunk_end);

	chunk_len = chunk_end - chunk_begin;

	tx = dmu_tx_create(os);
	dmu_tx_hold_free(tx, dn->dn_object, chunk_begin, chunk_len);

	/*
	* Mark this transaction as typically resulting in a net
	* reduction in space used.
	*/
	dmu_tx_mark_netfree(tx);
	err = dmu_tx_assign(tx, TXG_WAIT);
	if (err) {
	dmu_tx_abort(tx);
	return (err);
	}

	uint64_t txg = dmu_tx_get_txg(tx);

	mutex_enter(&dp->dp_lock);
	uint64_t long_free_dirty =
	dp->dp_long_free_dirty_pertxg[txg & TXG_MASK];
	mutex_exit(&dp->dp_lock);

	/*
	* To avoid filling up a TXG with just frees, wait for
	* the next TXG to open before freeing more chunks if
	* we have reached the threshold of frees.
	*/
	if (dirty_frees_threshold != 0 &&
	long_free_dirty >= dirty_frees_threshold) {
	DMU_TX_STAT_BUMP(dmu_tx_dirty_frees_delay);
	dmu_tx_commit(tx);
	txg_wait_open(dp, 0, B_TRUE);
	continue;
	}

	/*
	* In order to prevent unnecessary write throttling, for each
	* TXG, we track the cumulative size of L1 blocks being dirtied
	* in dnode_free_range() below. We compare this number to a
	* tunable threshold, past which we prevent new L1 dirty freeing
	* blocks from being added into the open TXG. See
	* dmu_free_long_range_impl() for details. The threshold
	* prevents write throttle activation due to dirty freeing L1
	* blocks taking up a large percentage of zfs_dirty_data_max.
	*/
	mutex_enter(&dp->dp_lock);
	dp->dp_long_free_dirty_pertxg[txg & TXG_MASK] +=
	l1blks << dn->dn_indblkshift;
	mutex_exit(&dp->dp_lock);
	DTRACE_PROBE3(free__long__range,
	uint64_t, long_free_dirty, uint64_t, chunk_len,
	uint64_t, txg);
	dnode_free_range(dn, chunk_begin, chunk_len, tx);

	dmu_tx_commit(tx);

	length -= chunk_len;
	}
	return (0);
	}

	int
	dmu_free_long_range(objset_t *os, uint64_t object,
	uint64_t offset, uint64_t length)
	{
	dnode_t *dn;
	int err;

	err = dnode_hold(os, object, FTAG, &dn);
	if (err != 0)
	return (err);
	err = dmu_free_long_range_impl(os, dn, offset, length);

	/*
	* It is important to zero out the maxblkid when freeing the entire
	* file, so that (a) subsequent calls to dmu_free_long_range_impl()
	* will take the fast path, and (b) dnode_reallocate() can verify
	* that the entire file has been freed.
	*/
	if (err == 0 && offset == 0 && length == DMU_OBJECT_END)
	dn->dn_maxblkid = 0;

	dnode_rele(dn, FTAG);
	return (err);
	}

	int
	dmu_free_long_object(objset_t *os, uint64_t object)
	{
	dmu_tx_t *tx;
	int err;

	err = dmu_free_long_range(os, object, 0, DMU_OBJECT_END);
	if (err != 0)
	return (err);

	tx = dmu_tx_create(os);
	dmu_tx_hold_bonus(tx, object);
	dmu_tx_hold_free(tx, object, 0, DMU_OBJECT_END);
	dmu_tx_mark_netfree(tx);
	err = dmu_tx_assign(tx, TXG_WAIT);
	if (err == 0) {
	if (err == 0)
	err = dmu_object_free(os, object, tx);

	dmu_tx_commit(tx);
	} else {
	dmu_tx_abort(tx);
	}

	return (err);
	}

	int
	dmu_free_range(objset_t *os, uint64_t object, uint64_t offset,
	uint64_t size, dmu_tx_t *tx)
	{
	dnode_t *dn;
	int err = dnode_hold(os, object, FTAG, &dn);
	if (err)
	return (err);
	ASSERT(offset < UINT64_MAX);
	ASSERT(size == DMU_OBJECT_END \|\| size <= UINT64_MAX - offset);
	dnode_free_range(dn, offset, size, tx);
	dnode_rele(dn, FTAG);
	return (0);
	}

	static int
	dmu_read_impl(dnode_t *dn, uint64_t offset, uint64_t size,
	void *buf, uint32_t flags)
	{
	dmu_buf_t **dbp;
	int numbufs, err = 0;

	/*
	* Deal with odd block sizes, where there can't be data past the first
	* block. If we ever do the tail block optimization, we will need to
	* handle that here as well.
	*/
	if (dn->dn_maxblkid == 0) {
	uint64_t newsz = offset > dn->dn_datablksz ? 0 :
	MIN(size, dn->dn_datablksz - offset);
	bzero((char *)buf + newsz, size - newsz);
	size = newsz;
	}

	while (size > 0) {
	uint64_t mylen = MIN(size, DMU_MAX_ACCESS / 2);
	int i;

	/*
	* NB: we could do this block-at-a-time, but it's nice
	* to be reading in parallel.
	*/
	err = dmu_buf_hold_array_by_dnode(dn, offset, mylen,
	TRUE, FTAG, &numbufs, &dbp, flags);
	if (err)
	break;

	for (i = 0; i < numbufs; i++) {
	uint64_t tocpy;
	int64_t bufoff;
	dmu_buf_t *db = dbp[i];

	ASSERT(size > 0);

	bufoff = offset - db->db_offset;
	tocpy = MIN(db->db_size - bufoff, size);

	(void) memcpy(buf, (char *)db->db_data + bufoff, tocpy);

	offset += tocpy;
	size -= tocpy;
	buf = (char *)buf + tocpy;
	}
	dmu_buf_rele_array(dbp, numbufs, FTAG);
	}
	return (err);
	}

	int
	dmu_read(objset_t *os, uint64_t object, uint64_t offset, uint64_t size,
	void *buf, uint32_t flags)
	{
	dnode_t *dn;
	int err;

	err = dnode_hold(os, object, FTAG, &dn);
	if (err != 0)
	return (err);

	err = dmu_read_impl(dn, offset, size, buf, flags);
	dnode_rele(dn, FTAG);
	return (err);
	}

	int
	dmu_read_by_dnode(dnode_t dn, uint64_t offset, uint64_t size, void buf,
	uint32_t flags)
	{
	return (dmu_read_impl(dn, offset, size, buf, flags));
	}

	static void
	dmu_write_impl(dmu_buf_t **dbp, int numbufs, uint64_t offset, uint64_t size,
	const void buf, dmu_tx_t tx)
	{
	int i;

	for (i = 0; i < numbufs; i++) {
	uint64_t tocpy;
	int64_t bufoff;
	dmu_buf_t *db = dbp[i];

	ASSERT(size > 0);

	bufoff = offset - db->db_offset;
	tocpy = MIN(db->db_size - bufoff, size);

	ASSERT(i == 0 \|\| i == numbufs-1 \|\| tocpy == db->db_size);

	if (tocpy == db->db_size)
	dmu_buf_will_fill(db, tx);
	else
	dmu_buf_will_dirty(db, tx);

	(void) memcpy((char *)db->db_data + bufoff, buf, tocpy);

	if (tocpy == db->db_size)
	dmu_buf_fill_done(db, tx);

	offset += tocpy;
	size -= tocpy;
	buf = (char *)buf + tocpy;
	}
	}

	void
	dmu_write(objset_t *os, uint64_t object, uint64_t offset, uint64_t size,
	const void buf, dmu_tx_t tx)
	{
	dmu_buf_t **dbp;
	int numbufs;

	if (size == 0)
	return;

	VERIFY0(dmu_buf_hold_array(os, object, offset, size,
	FALSE, FTAG, &numbufs, &dbp));
	dmu_write_impl(dbp, numbufs, offset, size, buf, tx);
	dmu_buf_rele_array(dbp, numbufs, FTAG);
	}

	/*
	* Note: Lustre is an external consumer of this interface.
	*/
	void
	dmu_write_by_dnode(dnode_t *dn, uint64_t offset, uint64_t size,
	const void buf, dmu_tx_t tx)
	{
	dmu_buf_t **dbp;
	int numbufs;

	if (size == 0)
	return;

	VERIFY0(dmu_buf_hold_array_by_dnode(dn, offset, size,
	FALSE, FTAG, &numbufs, &dbp, DMU_READ_PREFETCH));
	dmu_write_impl(dbp, numbufs, offset, size, buf, tx);
	dmu_buf_rele_array(dbp, numbufs, FTAG);
	}

	void
	dmu_prealloc(objset_t *os, uint64_t object, uint64_t offset, uint64_t size,
	dmu_tx_t *tx)
	{
	dmu_buf_t **dbp;
	int numbufs, i;

	if (size == 0)
	return;

	VERIFY(0 == dmu_buf_hold_array(os, object, offset, size,
	FALSE, FTAG, &numbufs, &dbp));

	for (i = 0; i < numbufs; i++) {
	dmu_buf_t *db = dbp[i];

	dmu_buf_will_not_fill(db, tx);
	}
	dmu_buf_rele_array(dbp, numbufs, FTAG);
	}

	void
	dmu_write_embedded(objset_t *os, uint64_t object, uint64_t offset,
	void *data, uint8_t etype, uint8_t comp, int uncompressed_size,
	int compressed_size, int byteorder, dmu_tx_t *tx)
	{
	dmu_buf_t *db;

	ASSERT3U(etype, <, NUM_BP_EMBEDDED_TYPES);
	ASSERT3U(comp, <, ZIO_COMPRESS_FUNCTIONS);
	VERIFY0(dmu_buf_hold_noread(os, object, offset,
	FTAG, &db));

	dmu_buf_write_embedded(db,
	data, (bp_embedded_type_t)etype, (enum zio_compress)comp,
	uncompressed_size, compressed_size, byteorder, tx);

	dmu_buf_rele(db, FTAG);
	}

	void
	dmu_redact(objset_t *os, uint64_t object, uint64_t offset, uint64_t size,
	dmu_tx_t *tx)
	{
	int numbufs, i;
	dmu_buf_t **dbp;

	VERIFY0(dmu_buf_hold_array(os, object, offset, size, FALSE, FTAG,
	&numbufs, &dbp));
	for (i = 0; i < numbufs; i++)
	dmu_buf_redact(dbp[i], tx);
	dmu_buf_rele_array(dbp, numbufs, FTAG);
	}

	#ifdef _KERNEL
	int
	dmu_read_uio_dnode(dnode_t dn, zfs_uio_t uio, uint64_t size)
	{
	dmu_buf_t **dbp;
	int numbufs, i, err;

	/*
	* NB: we could do this block-at-a-time, but it's nice
	* to be reading in parallel.
	*/
	err = dmu_buf_hold_array_by_dnode(dn, zfs_uio_offset(uio), size,
	TRUE, FTAG, &numbufs, &dbp, 0);
	if (err)
	return (err);

	for (i = 0; i < numbufs; i++) {
	uint64_t tocpy;
	int64_t bufoff;
	dmu_buf_t *db = dbp[i];

	ASSERT(size > 0);

	bufoff = zfs_uio_offset(uio) - db->db_offset;
	tocpy = MIN(db->db_size - bufoff, size);

	err = zfs_uio_fault_move((char *)db->db_data + bufoff, tocpy,
	UIO_READ, uio);

	if (err)
	break;

	size -= tocpy;
	}
	dmu_buf_rele_array(dbp, numbufs, FTAG);

	return (err);
	}

	/*
	* Read 'size' bytes into the uio buffer.
	* From object zdb->db_object.
	* Starting at zfs_uio_offset(uio).
	*
	* If the caller already has a dbuf in the target object
	* (e.g. its bonus buffer), this routine is faster than dmu_read_uio(),
	* because we don't have to find the dnode_t for the object.
	*/
	int
	dmu_read_uio_dbuf(dmu_buf_t zdb, zfs_uio_t uio, uint64_t size)
	{
	dmu_buf_impl_t db = (dmu_buf_impl_t )zdb;
	dnode_t *dn;
	int err;

	if (size == 0)
	return (0);

	DB_DNODE_ENTER(db);
	dn = DB_DNODE(db);
	err = dmu_read_uio_dnode(dn, uio, size);
	DB_DNODE_EXIT(db);

	return (err);
	}

	/*
	* Read 'size' bytes into the uio buffer.
	* From the specified object
	* Starting at offset zfs_uio_offset(uio).
	*/
	int
	dmu_read_uio(objset_t os, uint64_t object, zfs_uio_t uio, uint64_t size)
	{
	dnode_t *dn;
	int err;

	if (size == 0)
	return (0);

	err = dnode_hold(os, object, FTAG, &dn);
	if (err)
	return (err);

	err = dmu_read_uio_dnode(dn, uio, size);

	dnode_rele(dn, FTAG);

	return (err);
	}

	int
	dmu_write_uio_dnode(dnode_t dn, zfs_uio_t uio, uint64_t size, dmu_tx_t *tx)
	{
	dmu_buf_t **dbp;
	int numbufs;
	int err = 0;
	int i;

	err = dmu_buf_hold_array_by_dnode(dn, zfs_uio_offset(uio), size,
	FALSE, FTAG, &numbufs, &dbp, DMU_READ_PREFETCH);
	if (err)
	return (err);

	for (i = 0; i < numbufs; i++) {
	uint64_t tocpy;
	int64_t bufoff;
	dmu_buf_t *db = dbp[i];

	ASSERT(size > 0);

	bufoff = zfs_uio_offset(uio) - db->db_offset;
	tocpy = MIN(db->db_size - bufoff, size);

	ASSERT(i == 0 \|\| i == numbufs-1 \|\| tocpy == db->db_size);

	if (tocpy == db->db_size)
	dmu_buf_will_fill(db, tx);
	else
	dmu_buf_will_dirty(db, tx);

	/*
	* XXX zfs_uiomove could block forever (eg.nfs-backed
	* pages). There needs to be a uiolockdown() function
	* to lock the pages in memory, so that zfs_uiomove won't
	* block.
	*/
	err = zfs_uio_fault_move((char *)db->db_data + bufoff,
	tocpy, UIO_WRITE, uio);

	if (tocpy == db->db_size)
	dmu_buf_fill_done(db, tx);

	if (err)
	break;

	size -= tocpy;
	}

	dmu_buf_rele_array(dbp, numbufs, FTAG);
	return (err);
	}

	/*
	* Write 'size' bytes from the uio buffer.
	* To object zdb->db_object.
	* Starting at offset zfs_uio_offset(uio).
	*
	* If the caller already has a dbuf in the target object
	* (e.g. its bonus buffer), this routine is faster than dmu_write_uio(),
	* because we don't have to find the dnode_t for the object.
	*/
	int
	dmu_write_uio_dbuf(dmu_buf_t zdb, zfs_uio_t uio, uint64_t size,
	dmu_tx_t *tx)
	{
	dmu_buf_impl_t db = (dmu_buf_impl_t )zdb;
	dnode_t *dn;
	int err;

	if (size == 0)
	return (0);

	DB_DNODE_ENTER(db);
	dn = DB_DNODE(db);
	err = dmu_write_uio_dnode(dn, uio, size, tx);
	DB_DNODE_EXIT(db);

	return (err);
	}

	/*
	* Write 'size' bytes from the uio buffer.
	* To the specified object.
	* Starting at offset zfs_uio_offset(uio).
	*/
	int
	dmu_write_uio(objset_t os, uint64_t object, zfs_uio_t uio, uint64_t size,
	dmu_tx_t *tx)
	{
	dnode_t *dn;
	int err;

	if (size == 0)
	return (0);

	err = dnode_hold(os, object, FTAG, &dn);
	if (err)
	return (err);

	err = dmu_write_uio_dnode(dn, uio, size, tx);

	dnode_rele(dn, FTAG);

	return (err);
	}
	#endif /* _KERNEL */

	/*
	* Allocate a loaned anonymous arc buffer.
	*/
	arc_buf_t *
	dmu_request_arcbuf(dmu_buf_t *handle, int size)
	{
	dmu_buf_impl_t db = (dmu_buf_impl_t )handle;

	return (arc_loan_buf(db->db_objset->os_spa, B_FALSE, size));
	}

	/*
	* Free a loaned arc buffer.
	*/
	void
	dmu_return_arcbuf(arc_buf_t *buf)
	{
	arc_return_buf(buf, FTAG);
	arc_buf_destroy(buf, FTAG);
	}

	/*
	* A "lightweight" write is faster than a regular write (e.g.
	* dmu_write_by_dnode() or dmu_assign_arcbuf_by_dnode()), because it avoids the
	* CPU cost of creating a dmu_buf_impl_t and arc_buf_[hdr_]_t. However, the
	* data can not be read or overwritten until the transaction's txg has been
	* synced. This makes it appropriate for workloads that are known to be
	* (temporarily) write-only, like "zfs receive".
	*
	* A single block is written, starting at the specified offset in bytes. If
	* the call is successful, it returns 0 and the provided abd has been
	* consumed (the caller should not free it).
	*/
	int
	dmu_lightweight_write_by_dnode(dnode_t dn, uint64_t offset, abd_t abd,
	const zio_prop_t zp, enum zio_flag flags, dmu_tx_t tx)
	{
	dbuf_dirty_record_t *dr =
	dbuf_dirty_lightweight(dn, dbuf_whichblock(dn, 0, offset), tx);
	if (dr == NULL)
	return (SET_ERROR(EIO));
	dr->dt.dll.dr_abd = abd;
	dr->dt.dll.dr_props = *zp;
	dr->dt.dll.dr_flags = flags;
	return (0);
	}

	/*
	* When possible directly assign passed loaned arc buffer to a dbuf.
	* If this is not possible copy the contents of passed arc buf via
	* dmu_write().
	*/
	int
	dmu_assign_arcbuf_by_dnode(dnode_t dn, uint64_t offset, arc_buf_t buf,
	dmu_tx_t *tx)
	{
	dmu_buf_impl_t *db;
	objset_t *os = dn->dn_objset;
	uint64_t object = dn->dn_object;
	uint32_t blksz = (uint32_t)arc_buf_lsize(buf);
	uint64_t blkid;

	rw_enter(&dn->dn_struct_rwlock, RW_READER);
	blkid = dbuf_whichblock(dn, 0, offset);
	db = dbuf_hold(dn, blkid, FTAG);
	if (db == NULL)
	return (SET_ERROR(EIO));
	rw_exit(&dn->dn_struct_rwlock);

	/*
	* We can only assign if the offset is aligned and the arc buf is the
	* same size as the dbuf.
	*/
	if (offset == db->db.db_offset && blksz == db->db.db_size) {
	zfs_racct_write(blksz, 1);
	dbuf_assign_arcbuf(db, buf, tx);
	dbuf_rele(db, FTAG);
	} else {
	/* compressed bufs must always be assignable to their dbuf */
	ASSERT3U(arc_get_compression(buf), ==, ZIO_COMPRESS_OFF);
	ASSERT(!(buf->b_flags & ARC_BUF_FLAG_COMPRESSED));

	dbuf_rele(db, FTAG);
	dmu_write(os, object, offset, blksz, buf->b_data, tx);
	dmu_return_arcbuf(buf);
	}

	return (0);
	}

	int
	dmu_assign_arcbuf_by_dbuf(dmu_buf_t handle, uint64_t offset, arc_buf_t buf,
	dmu_tx_t *tx)
	{
	int err;
	dmu_buf_impl_t dbuf = (dmu_buf_impl_t )handle;

	DB_DNODE_ENTER(dbuf);
	err = dmu_assign_arcbuf_by_dnode(DB_DNODE(dbuf), offset, buf, tx);
	DB_DNODE_EXIT(dbuf);

	return (err);
	}

	typedef struct {
	dbuf_dirty_record_t *dsa_dr;
	dmu_sync_cb_t *dsa_done;
	zgd_t *dsa_zgd;
	dmu_tx_t *dsa_tx;
	} dmu_sync_arg_t;

	/* ARGSUSED */
	static void
	dmu_sync_ready(zio_t zio, arc_buf_t buf, void *varg)
	{
	dmu_sync_arg_t *dsa = varg;
	dmu_buf_t *db = dsa->dsa_zgd->zgd_db;
	blkptr_t *bp = zio->io_bp;

	if (zio->io_error == 0) {
	if (BP_IS_HOLE(bp)) {
	/*
	* A block of zeros may compress to a hole, but the
	* block size still needs to be known for replay.
	*/
	BP_SET_LSIZE(bp, db->db_size);
	} else if (!BP_IS_EMBEDDED(bp)) {
	ASSERT(BP_GET_LEVEL(bp) == 0);
	BP_SET_FILL(bp, 1);
	}
	}
	}

	static void
	dmu_sync_late_arrival_ready(zio_t *zio)
	{
	dmu_sync_ready(zio, NULL, zio->io_private);
	}

	/* ARGSUSED */
	static void
	dmu_sync_done(zio_t zio, arc_buf_t buf, void *varg)
	{
	dmu_sync_arg_t *dsa = varg;
	dbuf_dirty_record_t *dr = dsa->dsa_dr;
	dmu_buf_impl_t *db = dr->dr_dbuf;
	zgd_t *zgd = dsa->dsa_zgd;

	/*
	* Record the vdev(s) backing this blkptr so they can be flushed after
	* the writes for the lwb have completed.
	*/
	if (zio->io_error == 0) {
	zil_lwb_add_block(zgd->zgd_lwb, zgd->zgd_bp);
	}

	mutex_enter(&db->db_mtx);
	ASSERT(dr->dt.dl.dr_override_state == DR_IN_DMU_SYNC);
	if (zio->io_error == 0) {
	dr->dt.dl.dr_nopwrite = !!(zio->io_flags & ZIO_FLAG_NOPWRITE);
	if (dr->dt.dl.dr_nopwrite) {
	blkptr_t *bp = zio->io_bp;
	blkptr_t *bp_orig = &zio->io_bp_orig;
	uint8_t chksum = BP_GET_CHECKSUM(bp_orig);

	ASSERT(BP_EQUAL(bp, bp_orig));
	VERIFY(BP_EQUAL(bp, db->db_blkptr));
	ASSERT(zio->io_prop.zp_compress != ZIO_COMPRESS_OFF);
	VERIFY(zio_checksum_table[chksum].ci_flags &
	ZCHECKSUM_FLAG_NOPWRITE);
	}
	dr->dt.dl.dr_overridden_by = *zio->io_bp;
	dr->dt.dl.dr_override_state = DR_OVERRIDDEN;
	dr->dt.dl.dr_copies = zio->io_prop.zp_copies;

	/*
	* Old style holes are filled with all zeros, whereas
	* new-style holes maintain their lsize, type, level,
	* and birth time (see zio_write_compress). While we
	* need to reset the BP_SET_LSIZE() call that happened
	* in dmu_sync_ready for old style holes, we do not
	* want to wipe out the information contained in new
	* style holes. Thus, only zero out the block pointer if
	* it's an old style hole.
	*/
	if (BP_IS_HOLE(&dr->dt.dl.dr_overridden_by) &&
	dr->dt.dl.dr_overridden_by.blk_birth == 0)
	BP_ZERO(&dr->dt.dl.dr_overridden_by);
	} else {
	dr->dt.dl.dr_override_state = DR_NOT_OVERRIDDEN;
	}
	cv_broadcast(&db->db_changed);
	mutex_exit(&db->db_mtx);

	dsa->dsa_done(dsa->dsa_zgd, zio->io_error);

	kmem_free(dsa, sizeof (*dsa));
	}

	static void
	dmu_sync_late_arrival_done(zio_t *zio)
	{
	blkptr_t *bp = zio->io_bp;
	dmu_sync_arg_t *dsa = zio->io_private;
	zgd_t *zgd = dsa->dsa_zgd;

	if (zio->io_error == 0) {
	/*
	* Record the vdev(s) backing this blkptr so they can be
	* flushed after the writes for the lwb have completed.
	*/
	zil_lwb_add_block(zgd->zgd_lwb, zgd->zgd_bp);

	if (!BP_IS_HOLE(bp)) {
	blkptr_t *bp_orig __maybe_unused = &zio->io_bp_orig;
	ASSERT(!(zio->io_flags & ZIO_FLAG_NOPWRITE));
	ASSERT(BP_IS_HOLE(bp_orig) \|\| !BP_EQUAL(bp, bp_orig));
	ASSERT(zio->io_bp->blk_birth == zio->io_txg);
	ASSERT(zio->io_txg > spa_syncing_txg(zio->io_spa));
	zio_free(zio->io_spa, zio->io_txg, zio->io_bp);
	}
	}

	dmu_tx_commit(dsa->dsa_tx);

	dsa->dsa_done(dsa->dsa_zgd, zio->io_error);

	abd_free(zio->io_abd);
	kmem_free(dsa, sizeof (*dsa));
	}

	static int
	dmu_sync_late_arrival(zio_t pio, objset_t os, dmu_sync_cb_t done, zgd_t zgd,
	zio_prop_t zp, zbookmark_phys_t zb)
	{
	dmu_sync_arg_t *dsa;
	dmu_tx_t *tx;

	tx = dmu_tx_create(os);
	dmu_tx_hold_space(tx, zgd->zgd_db->db_size);
	if (dmu_tx_assign(tx, TXG_WAIT) != 0) {
	dmu_tx_abort(tx);
	/* Make zl_get_data do txg_waited_synced() */
	return (SET_ERROR(EIO));
	}

	/*
	* In order to prevent the zgd's lwb from being free'd prior to
	* dmu_sync_late_arrival_done() being called, we have to ensure
	* the lwb's "max txg" takes this tx's txg into account.
	*/
	zil_lwb_add_txg(zgd->zgd_lwb, dmu_tx_get_txg(tx));

	dsa = kmem_alloc(sizeof (dmu_sync_arg_t), KM_SLEEP);
	dsa->dsa_dr = NULL;
	dsa->dsa_done = done;
	dsa->dsa_zgd = zgd;
	dsa->dsa_tx = tx;

	/*
	* Since we are currently syncing this txg, it's nontrivial to
	* determine what BP to nopwrite against, so we disable nopwrite.
	*
	* When syncing, the db_blkptr is initially the BP of the previous
	* txg. We can not nopwrite against it because it will be changed
	* (this is similar to the non-late-arrival case where the dbuf is
	* dirty in a future txg).
	*
	* Then dbuf_write_ready() sets bp_blkptr to the location we will write.
	* We can not nopwrite against it because although the BP will not
	* (typically) be changed, the data has not yet been persisted to this
	* location.
	*
	* Finally, when dbuf_write_done() is called, it is theoretically
	* possible to always nopwrite, because the data that was written in
	* this txg is the same data that we are trying to write. However we
	* would need to check that this dbuf is not dirty in any future
	* txg's (as we do in the normal dmu_sync() path). For simplicity, we
	* don't nopwrite in this case.
	*/
	zp->zp_nopwrite = B_FALSE;

	zio_nowait(zio_write(pio, os->os_spa, dmu_tx_get_txg(tx), zgd->zgd_bp,
	abd_get_from_buf(zgd->zgd_db->db_data, zgd->zgd_db->db_size),
	zgd->zgd_db->db_size, zgd->zgd_db->db_size, zp,
	dmu_sync_late_arrival_ready, NULL, NULL, dmu_sync_late_arrival_done,
	dsa, ZIO_PRIORITY_SYNC_WRITE, ZIO_FLAG_CANFAIL, zb));

	return (0);
	}

	/*
	* Intent log support: sync the block associated with db to disk.
	* N.B. and XXX: the caller is responsible for making sure that the
	* data isn't changing while dmu_sync() is writing it.
	*
	* Return values:
	*
	* EEXIST: this txg has already been synced, so there's nothing to do.
	* The caller should not log the write.
	*
	* ENOENT: the block was dbuf_free_range()'d, so there's nothing to do.
	* The caller should not log the write.
	*
	* EALREADY: this block is already in the process of being synced.
	* The caller should track its progress (somehow).
	*
	* EIO: could not do the I/O.
	* The caller should do a txg_wait_synced().
	*
	* 0: the I/O has been initiated.
	* The caller should log this blkptr in the done callback.
	* It is possible that the I/O will fail, in which case
	* the error will be reported to the done callback and
	* propagated to pio from zio_done().
	*/
	int
	dmu_sync(zio_t pio, uint64_t txg, dmu_sync_cb_t done, zgd_t *zgd)
	{
	dmu_buf_impl_t db = (dmu_buf_impl_t )zgd->zgd_db;
	objset_t *os = db->db_objset;
	dsl_dataset_t *ds = os->os_dsl_dataset;
	dbuf_dirty_record_t dr, dr_next;
	dmu_sync_arg_t *dsa;
	zbookmark_phys_t zb;
	zio_prop_t zp;
	dnode_t *dn;

	ASSERT(pio != NULL);
	ASSERT(txg != 0);

	SET_BOOKMARK(&zb, ds->ds_object,
	db->db.db_object, db->db_level, db->db_blkid);

	DB_DNODE_ENTER(db);
	dn = DB_DNODE(db);
	dmu_write_policy(os, dn, db->db_level, WP_DMU_SYNC, &zp);
	DB_DNODE_EXIT(db);

	/*
	* If we're frozen (running ziltest), we always need to generate a bp.
	*/
	if (txg > spa_freeze_txg(os->os_spa))
	return (dmu_sync_late_arrival(pio, os, done, zgd, &zp, &zb));

	/*
	* Grabbing db_mtx now provides a barrier between dbuf_sync_leaf()
	* and us. If we determine that this txg is not yet syncing,
	* but it begins to sync a moment later, that's OK because the
	* sync thread will block in dbuf_sync_leaf() until we drop db_mtx.
	*/
	mutex_enter(&db->db_mtx);

	if (txg <= spa_last_synced_txg(os->os_spa)) {
	/*
	* This txg has already synced. There's nothing to do.
	*/
	mutex_exit(&db->db_mtx);
	return (SET_ERROR(EEXIST));
	}

	if (txg <= spa_syncing_txg(os->os_spa)) {
	/*
	* This txg is currently syncing, so we can't mess with
	* the dirty record anymore; just write a new log block.
	*/
	mutex_exit(&db->db_mtx);
	return (dmu_sync_late_arrival(pio, os, done, zgd, &zp, &zb));
	}

	dr = dbuf_find_dirty_eq(db, txg);

	if (dr == NULL) {
	/*
	* There's no dr for this dbuf, so it must have been freed.
	* There's no need to log writes to freed blocks, so we're done.
	*/
	mutex_exit(&db->db_mtx);
	return (SET_ERROR(ENOENT));
	}

	dr_next = list_next(&db->db_dirty_records, dr);
	ASSERT(dr_next == NULL \|\| dr_next->dr_txg < txg);

	if (db->db_blkptr != NULL) {
	/*
	* We need to fill in zgd_bp with the current blkptr so that
	* the nopwrite code can check if we're writing the same
	* data that's already on disk. We can only nopwrite if we
	* are sure that after making the copy, db_blkptr will not
	* change until our i/o completes. We ensure this by
	* holding the db_mtx, and only allowing nopwrite if the
	* block is not already dirty (see below). This is verified
	* by dmu_sync_done(), which VERIFYs that the db_blkptr has
	* not changed.
	*/
	zgd->zgd_bp = db->db_blkptr;
	}

	/*
	* Assume the on-disk data is X, the current syncing data (in
	* txg - 1) is Y, and the current in-memory data is Z (currently
	* in dmu_sync).
	*
	* We usually want to perform a nopwrite if X and Z are the
	* same. However, if Y is different (i.e. the BP is going to
	* change before this write takes effect), then a nopwrite will
	* be incorrect - we would override with X, which could have
	* been freed when Y was written.
	*
	* (Note that this is not a concern when we are nop-writing from
	* syncing context, because X and Y must be identical, because
	* all previous txgs have been synced.)
	*
	* Therefore, we disable nopwrite if the current BP could change
	* before this TXG. There are two ways it could change: by
	* being dirty (dr_next is non-NULL), or by being freed
	* (dnode_block_freed()). This behavior is verified by
	* zio_done(), which VERIFYs that the override BP is identical
	* to the on-disk BP.
	*/
	DB_DNODE_ENTER(db);
	dn = DB_DNODE(db);
	if (dr_next != NULL \|\| dnode_block_freed(dn, db->db_blkid))
	zp.zp_nopwrite = B_FALSE;
	DB_DNODE_EXIT(db);

	ASSERT(dr->dr_txg == txg);
	if (dr->dt.dl.dr_override_state == DR_IN_DMU_SYNC \|\|
	dr->dt.dl.dr_override_state == DR_OVERRIDDEN) {
	/*
	* We have already issued a sync write for this buffer,
	* or this buffer has already been synced. It could not
	* have been dirtied since, or we would have cleared the state.
	*/
	mutex_exit(&db->db_mtx);
	return (SET_ERROR(EALREADY));
	}

	ASSERT(dr->dt.dl.dr_override_state == DR_NOT_OVERRIDDEN);
	dr->dt.dl.dr_override_state = DR_IN_DMU_SYNC;
	mutex_exit(&db->db_mtx);

	dsa = kmem_alloc(sizeof (dmu_sync_arg_t), KM_SLEEP);
	dsa->dsa_dr = dr;
	dsa->dsa_done = done;
	dsa->dsa_zgd = zgd;
	dsa->dsa_tx = NULL;

	zio_nowait(arc_write(pio, os->os_spa, txg,
	zgd->zgd_bp, dr->dt.dl.dr_data, DBUF_IS_L2CACHEABLE(db),
	&zp, dmu_sync_ready, NULL, NULL, dmu_sync_done, dsa,
	ZIO_PRIORITY_SYNC_WRITE, ZIO_FLAG_CANFAIL, &zb));

	return (0);
	}

	int
	dmu_object_set_nlevels(objset_t os, uint64_t object, int nlevels, dmu_tx_t tx)
	{
	dnode_t *dn;
	int err;

	err = dnode_hold(os, object, FTAG, &dn);
	if (err)
	return (err);
	err = dnode_set_nlevels(dn, nlevels, tx);
	dnode_rele(dn, FTAG);
	return (err);
	}

	int
	dmu_object_set_blocksize(objset_t *os, uint64_t object, uint64_t size, int ibs,
	dmu_tx_t *tx)
	{
	dnode_t *dn;
	int err;

	err = dnode_hold(os, object, FTAG, &dn);
	if (err)
	return (err);
	err = dnode_set_blksz(dn, size, ibs, tx);
	dnode_rele(dn, FTAG);
	return (err);
	}

	int
	dmu_object_set_maxblkid(objset_t *os, uint64_t object, uint64_t maxblkid,
	dmu_tx_t *tx)
	{
	dnode_t *dn;
	int err;

	err = dnode_hold(os, object, FTAG, &dn);
	if (err)
	return (err);
	rw_enter(&dn->dn_struct_rwlock, RW_WRITER);
	dnode_new_blkid(dn, maxblkid, tx, B_FALSE, B_TRUE);
	rw_exit(&dn->dn_struct_rwlock);
	dnode_rele(dn, FTAG);
	return (0);
	}

	void
	dmu_object_set_checksum(objset_t *os, uint64_t object, uint8_t checksum,
	dmu_tx_t *tx)
	{
	dnode_t *dn;

	/*
	* Send streams include each object's checksum function. This
	* check ensures that the receiving system can understand the
	* checksum function transmitted.
	*/
	ASSERT3U(checksum, <, ZIO_CHECKSUM_LEGACY_FUNCTIONS);

	VERIFY0(dnode_hold(os, object, FTAG, &dn));
	ASSERT3U(checksum, <, ZIO_CHECKSUM_FUNCTIONS);
	dn->dn_checksum = checksum;
	dnode_setdirty(dn, tx);
	dnode_rele(dn, FTAG);
	}

	void
	dmu_object_set_compress(objset_t *os, uint64_t object, uint8_t compress,
	dmu_tx_t *tx)
	{
	dnode_t *dn;

	/*
	* Send streams include each object's compression function. This
	* check ensures that the receiving system can understand the
	* compression function transmitted.
	*/
	ASSERT3U(compress, <, ZIO_COMPRESS_LEGACY_FUNCTIONS);

	VERIFY0(dnode_hold(os, object, FTAG, &dn));
	dn->dn_compress = compress;
	dnode_setdirty(dn, tx);
	dnode_rele(dn, FTAG);
	}

	/*
	* When the "redundant_metadata" property is set to "most", only indirect
	* blocks of this level and higher will have an additional ditto block.
	*/
	int zfs_redundant_metadata_most_ditto_level = 2;

	void
	dmu_write_policy(objset_t os, dnode_t dn, int level, int wp, zio_prop_t *zp)
	{
	dmu_object_type_t type = dn ? dn->dn_type : DMU_OT_OBJSET;
	boolean_t ismd = (level > 0 \|\| DMU_OT_IS_METADATA(type) \|\|
	(wp & WP_SPILL));
	enum zio_checksum checksum = os->os_checksum;
	enum zio_compress compress = os->os_compress;
	uint8_t complevel = os->os_complevel;
	enum zio_checksum dedup_checksum = os->os_dedup_checksum;
	boolean_t dedup = B_FALSE;
	boolean_t nopwrite = B_FALSE;
	boolean_t dedup_verify = os->os_dedup_verify;
	boolean_t encrypt = B_FALSE;
	int copies = os->os_copies;

	/*
	* We maintain different write policies for each of the following
	* types of data:
	* 1. metadata
	* 2. preallocated blocks (i.e. level-0 blocks of a dump device)
	* 3. all other level 0 blocks
	*/
	if (ismd) {
	/*
	* XXX -- we should design a compression algorithm
	* that specializes in arrays of bps.
	*/
	compress = zio_compress_select(os->os_spa,
	ZIO_COMPRESS_ON, ZIO_COMPRESS_ON);

	/*
	* Metadata always gets checksummed. If the data
	* checksum is multi-bit correctable, and it's not a
	* ZBT-style checksum, then it's suitable for metadata
	* as well. Otherwise, the metadata checksum defaults
	* to fletcher4.
	*/
	if (!(zio_checksum_table[checksum].ci_flags &
	ZCHECKSUM_FLAG_METADATA) \|\|
	(zio_checksum_table[checksum].ci_flags &
	ZCHECKSUM_FLAG_EMBEDDED))
	checksum = ZIO_CHECKSUM_FLETCHER_4;

	if (os->os_redundant_metadata == ZFS_REDUNDANT_METADATA_ALL \|\|
	(os->os_redundant_metadata ==
	ZFS_REDUNDANT_METADATA_MOST &&
	(level >= zfs_redundant_metadata_most_ditto_level \|\|
	DMU_OT_IS_METADATA(type) \|\| (wp & WP_SPILL))))
	copies++;
	} else if (wp & WP_NOFILL) {
	ASSERT(level == 0);

	/*
	* If we're writing preallocated blocks, we aren't actually
	* writing them so don't set any policy properties. These
	* blocks are currently only used by an external subsystem
	* outside of zfs (i.e. dump) and not written by the zio
	* pipeline.
	*/
	compress = ZIO_COMPRESS_OFF;
	checksum = ZIO_CHECKSUM_OFF;
	} else {
	compress = zio_compress_select(os->os_spa, dn->dn_compress,
	compress);
	complevel = zio_complevel_select(os->os_spa, compress,
	complevel, complevel);

	checksum = (dedup_checksum == ZIO_CHECKSUM_OFF) ?
	zio_checksum_select(dn->dn_checksum, checksum) :
	dedup_checksum;

	/*
	* Determine dedup setting. If we are in dmu_sync(),
	* we won't actually dedup now because that's all
	* done in syncing context; but we do want to use the
	* dedup checksum. If the checksum is not strong
	* enough to ensure unique signatures, force
	* dedup_verify.
	*/
	if (dedup_checksum != ZIO_CHECKSUM_OFF) {
	dedup = (wp & WP_DMU_SYNC) ? B_FALSE : B_TRUE;
	if (!(zio_checksum_table[checksum].ci_flags &
	ZCHECKSUM_FLAG_DEDUP))
	dedup_verify = B_TRUE;
	}

	/*
	* Enable nopwrite if we have secure enough checksum
	* algorithm (see comment in zio_nop_write) and
	* compression is enabled. We don't enable nopwrite if
	* dedup is enabled as the two features are mutually
	* exclusive.
	*/
	nopwrite = (!dedup && (zio_checksum_table[checksum].ci_flags &
	ZCHECKSUM_FLAG_NOPWRITE) &&
	compress != ZIO_COMPRESS_OFF && zfs_nopwrite_enabled);
	}

	/*
	* All objects in an encrypted objset are protected from modification
	* via a MAC. Encrypted objects store their IV and salt in the last DVA
	* in the bp, so we cannot use all copies. Encrypted objects are also
	* not subject to nopwrite since writing the same data will still
	* result in a new ciphertext. Only encrypted blocks can be dedup'd
	* to avoid ambiguity in the dedup code since the DDT does not store
	* object types.
	*/
	if (os->os_encrypted && (wp & WP_NOFILL) == 0) {
	encrypt = B_TRUE;

	if (DMU_OT_IS_ENCRYPTED(type)) {
	copies = MIN(copies, SPA_DVAS_PER_BP - 1);
	nopwrite = B_FALSE;
	} else {
	dedup = B_FALSE;
	}

	if (level <= 0 &&
	(type == DMU_OT_DNODE \|\| type == DMU_OT_OBJSET)) {
	compress = ZIO_COMPRESS_EMPTY;
	}
	}

	zp->zp_compress = compress;
	zp->zp_complevel = complevel;
	zp->zp_checksum = checksum;
	zp->zp_type = (wp & WP_SPILL) ? dn->dn_bonustype : type;
	zp->zp_level = level;
	zp->zp_copies = MIN(copies, spa_max_replication(os->os_spa));
	zp->zp_dedup = dedup;
	zp->zp_dedup_verify = dedup && dedup_verify;
	zp->zp_nopwrite = nopwrite;
	zp->zp_encrypt = encrypt;
	zp->zp_byteorder = ZFS_HOST_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);
	zp->zp_zpl_smallblk = DMU_OT_IS_FILE(zp->zp_type) ?
	os->os_zpl_special_smallblock : 0;

	ASSERT3U(zp->zp_compress, !=, ZIO_COMPRESS_INHERIT);
	}

	/*
	* This function is only called from zfs_holey_common() for zpl_llseek()
	* in order to determine the location of holes. In order to accurately
	* report holes all dirty data must be synced to disk. This causes extremely
	* poor performance when seeking for holes in a dirty file. As a compromise,
	* only provide hole data when the dnode is clean. When a dnode is dirty
	* report the dnode as having no holes which is always a safe thing to do.
	*/
	int
	dmu_offset_next(objset_t os, uint64_t object, boolean_t hole, uint64_t off)
	{
	dnode_t *dn;
	- int i, err;
	- boolean_t clean = B_TRUE;
	+ int err;

	+restart:
	err = dnode_hold(os, object, FTAG, &dn);
	if (err)
	return (err);

	- /*
	- * Check if dnode is dirty
	- */
	- for (i = 0; i < TXG_SIZE; i++) {
	- if (multilist_link_active(&dn->dn_dirty_link[i])) {
	- clean = B_FALSE;
	- break;
	- }
	- }
	+ rw_enter(&dn->dn_struct_rwlock, RW_READER);

	- /*
	- * If compatibility option is on, sync any current changes before
	- * we go trundling through the block pointers.
	- */
	- if (!clean && zfs_dmu_offset_next_sync) {
	- clean = B_TRUE;
	- dnode_rele(dn, FTAG);
	- txg_wait_synced(dmu_objset_pool(os), 0);
	- err = dnode_hold(os, object, FTAG, &dn);
	- if (err)
	- return (err);
	- }
	+ if (dnode_is_dirty(dn)) {
	+ /*
	+ * If the zfs_dmu_offset_next_sync module option is enabled
	+ * then strict hole reporting has been requested. Dirty
	+ * dnodes must be synced to disk to accurately report all
	+ * holes. When disabled (the default) dirty dnodes are
	+ * reported to not have any holes which is always safe.
	+ *
	+ * When called by zfs_holey_common() the zp->z_rangelock
	+ * is held to prevent zfs_write() and mmap writeback from
	+ * re-dirtying the dnode after txg_wait_synced().
	+ */
	+ if (zfs_dmu_offset_next_sync) {
	+ rw_exit(&dn->dn_struct_rwlock);
	+ dnode_rele(dn, FTAG);
	+ txg_wait_synced(dmu_objset_pool(os), 0);
	+ goto restart;
	+ }

	- if (clean)
	- err = dnode_next_offset(dn,
	- (hole ? DNODE_FIND_HOLE : 0), off, 1, 1, 0);
	- else
	err = SET_ERROR(EBUSY);
	+ } else {
	+ err = dnode_next_offset(dn, DNODE_FIND_HAVELOCK \|
	+ (hole ? DNODE_FIND_HOLE : 0), off, 1, 1, 0);
	+ }

	+ rw_exit(&dn->dn_struct_rwlock);
	dnode_rele(dn, FTAG);

	return (err);
	}

	void
	__dmu_object_info_from_dnode(dnode_t dn, dmu_object_info_t doi)
	{
	dnode_phys_t *dnp = dn->dn_phys;

	doi->doi_data_block_size = dn->dn_datablksz;
	doi->doi_metadata_block_size = dn->dn_indblkshift ?
	1ULL << dn->dn_indblkshift : 0;
	doi->doi_type = dn->dn_type;
	doi->doi_bonus_type = dn->dn_bonustype;
	doi->doi_bonus_size = dn->dn_bonuslen;
	doi->doi_dnodesize = dn->dn_num_slots << DNODE_SHIFT;
	doi->doi_indirection = dn->dn_nlevels;
	doi->doi_checksum = dn->dn_checksum;
	doi->doi_compress = dn->dn_compress;
	doi->doi_nblkptr = dn->dn_nblkptr;
	doi->doi_physical_blocks_512 = (DN_USED_BYTES(dnp) + 256) >> 9;
	doi->doi_max_offset = (dn->dn_maxblkid + 1) * dn->dn_datablksz;
	doi->doi_fill_count = 0;
	for (int i = 0; i < dnp->dn_nblkptr; i++)
	doi->doi_fill_count += BP_GET_FILL(&dnp->dn_blkptr[i]);
	}

	void
	dmu_object_info_from_dnode(dnode_t dn, dmu_object_info_t doi)
	{
	rw_enter(&dn->dn_struct_rwlock, RW_READER);
	mutex_enter(&dn->dn_mtx);

	__dmu_object_info_from_dnode(dn, doi);

	mutex_exit(&dn->dn_mtx);
	rw_exit(&dn->dn_struct_rwlock);
	}

	/*
	* Get information on a DMU object.
	* If doi is NULL, just indicates whether the object exists.
	*/
	int
	dmu_object_info(objset_t os, uint64_t object, dmu_object_info_t doi)
	{
	dnode_t *dn;
	int err = dnode_hold(os, object, FTAG, &dn);

	if (err)
	return (err);

	if (doi != NULL)
	dmu_object_info_from_dnode(dn, doi);

	dnode_rele(dn, FTAG);
	return (0);
	}

	/*
	* As above, but faster; can be used when you have a held dbuf in hand.
	*/
	void
	dmu_object_info_from_db(dmu_buf_t db_fake, dmu_object_info_t doi)
	{
	dmu_buf_impl_t db = (dmu_buf_impl_t )db_fake;

	DB_DNODE_ENTER(db);
	dmu_object_info_from_dnode(DB_DNODE(db), doi);
	DB_DNODE_EXIT(db);
	}

	/*
	* Faster still when you only care about the size.
	*/
	void
	dmu_object_size_from_db(dmu_buf_t db_fake, uint32_t blksize,
	u_longlong_t *nblk512)
	{
	dmu_buf_impl_t db = (dmu_buf_impl_t )db_fake;
	dnode_t *dn;

	DB_DNODE_ENTER(db);
	dn = DB_DNODE(db);

	*blksize = dn->dn_datablksz;
	/* add in number of slots used for the dnode itself */
	*nblk512 = ((DN_USED_BYTES(dn->dn_phys) + SPA_MINBLOCKSIZE/2) >>
	SPA_MINBLOCKSHIFT) + dn->dn_num_slots;
	DB_DNODE_EXIT(db);
	}

	void
	dmu_object_dnsize_from_db(dmu_buf_t db_fake, int dnsize)
	{
	dmu_buf_impl_t db = (dmu_buf_impl_t )db_fake;
	dnode_t *dn;

	DB_DNODE_ENTER(db);
	dn = DB_DNODE(db);
	*dnsize = dn->dn_num_slots << DNODE_SHIFT;
	DB_DNODE_EXIT(db);
	}

	void
	byteswap_uint64_array(void *vbuf, size_t size)
	{
	uint64_t *buf = vbuf;
	size_t count = size >> 3;
	int i;

	ASSERT((size & 7) == 0);

	for (i = 0; i < count; i++)
	buf[i] = BSWAP_64(buf[i]);
	}

	void
	byteswap_uint32_array(void *vbuf, size_t size)
	{
	uint32_t *buf = vbuf;
	size_t count = size >> 2;
	int i;

	ASSERT((size & 3) == 0);

	for (i = 0; i < count; i++)
	buf[i] = BSWAP_32(buf[i]);
	}

	void
	byteswap_uint16_array(void *vbuf, size_t size)
	{
	uint16_t *buf = vbuf;
	size_t count = size >> 1;
	int i;

	ASSERT((size & 1) == 0);

	for (i = 0; i < count; i++)
	buf[i] = BSWAP_16(buf[i]);
	}

	/* ARGSUSED */
	void
	byteswap_uint8_array(void *vbuf, size_t size)
	{
	}

	void
	dmu_init(void)
	{
	abd_init();
	zfs_dbgmsg_init();
	sa_cache_init();
	dmu_objset_init();
	dnode_init();
	zfetch_init();
	dmu_tx_init();
	l2arc_init();
	arc_init();
	dbuf_init();
	}

	void
	dmu_fini(void)
	{
	arc_fini(); /* arc depends on l2arc, so arc must go first */
	l2arc_fini();
	dmu_tx_fini();
	zfetch_fini();
	dbuf_fini();
	dnode_fini();
	dmu_objset_fini();
	sa_cache_fini();
	zfs_dbgmsg_fini();
	abd_fini();
	}

	EXPORT_SYMBOL(dmu_bonus_hold);
	EXPORT_SYMBOL(dmu_bonus_hold_by_dnode);
	EXPORT_SYMBOL(dmu_buf_hold_array_by_bonus);
	EXPORT_SYMBOL(dmu_buf_rele_array);
	EXPORT_SYMBOL(dmu_prefetch);
	EXPORT_SYMBOL(dmu_free_range);
	EXPORT_SYMBOL(dmu_free_long_range);
	EXPORT_SYMBOL(dmu_free_long_object);
	EXPORT_SYMBOL(dmu_read);
	EXPORT_SYMBOL(dmu_read_by_dnode);
	EXPORT_SYMBOL(dmu_write);
	EXPORT_SYMBOL(dmu_write_by_dnode);
	EXPORT_SYMBOL(dmu_prealloc);
	EXPORT_SYMBOL(dmu_object_info);
	EXPORT_SYMBOL(dmu_object_info_from_dnode);
	EXPORT_SYMBOL(dmu_object_info_from_db);
	EXPORT_SYMBOL(dmu_object_size_from_db);
	EXPORT_SYMBOL(dmu_object_dnsize_from_db);
	EXPORT_SYMBOL(dmu_object_set_nlevels);
	EXPORT_SYMBOL(dmu_object_set_blocksize);
	EXPORT_SYMBOL(dmu_object_set_maxblkid);
	EXPORT_SYMBOL(dmu_object_set_checksum);
	EXPORT_SYMBOL(dmu_object_set_compress);
	EXPORT_SYMBOL(dmu_offset_next);
	EXPORT_SYMBOL(dmu_write_policy);
	EXPORT_SYMBOL(dmu_sync);
	EXPORT_SYMBOL(dmu_request_arcbuf);
	EXPORT_SYMBOL(dmu_return_arcbuf);
	EXPORT_SYMBOL(dmu_assign_arcbuf_by_dnode);
	EXPORT_SYMBOL(dmu_assign_arcbuf_by_dbuf);
	EXPORT_SYMBOL(dmu_buf_hold);
	EXPORT_SYMBOL(dmu_ot);

	/* BEGIN CSTYLED */
	ZFS_MODULE_PARAM(zfs, zfs_, nopwrite_enabled, INT, ZMOD_RW,
	"Enable NOP writes");

	ZFS_MODULE_PARAM(zfs, zfs_, per_txg_dirty_frees_percent, ULONG, ZMOD_RW,
	"Percentage of dirtied blocks from frees in one TXG");

	ZFS_MODULE_PARAM(zfs, zfs_, dmu_offset_next_sync, INT, ZMOD_RW,
	"Enable forcing txg sync to find holes");

	ZFS_MODULE_PARAM(zfs, , dmu_prefetch_max, INT, ZMOD_RW,
	"Limit one prefetch call to this size");
	/* END CSTYLED */
	diff --git a/sys/contrib/openzfs/module/zfs/dmu_send.c b/sys/contrib/openzfs/module/zfs/dmu_send.c
	index 0658e13c2d25..2f2fd4c3d6c8 100644
	--- a/sys/contrib/openzfs/module/zfs/dmu_send.c
	+++ b/sys/contrib/openzfs/module/zfs/dmu_send.c
	@@ -1,3096 +1,3107 @@
	/*
	* 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, 2018 by Delphix. All rights reserved.
	* Copyright (c) 2014, Joyent, Inc. All rights reserved.
	* Copyright 2014 HybridCluster. All rights reserved.
	* Copyright 2016 RackTop Systems.
	* Copyright (c) 2016 Actifio, Inc. 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_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/spa_impl.h>
	#include <sys/zfs_ioctl.h>
	#include <sys/zap.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/dmu_send.h>
	#include <sys/dmu_recv.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/zvol.h>
	#include <sys/policy.h>
	#include <sys/objlist.h>
	#ifdef _KERNEL
	#include <sys/zfs_vfsops.h>
	#endif

	/* Set this tunable to TRUE to replace corrupt data with 0x2f5baddb10c */
	int zfs_send_corrupt_data = B_FALSE;
	/*
	* This tunable controls the amount of data (measured in bytes) that will be
	* prefetched by zfs send. If the main thread is blocking on reads that haven't
	* completed, this variable might need to be increased. If instead the main
	* thread is issuing new reads because the prefetches have fallen out of the
	* cache, this may need to be decreased.
	*/
	int zfs_send_queue_length = SPA_MAXBLOCKSIZE;
	/*
	* This tunable controls the length of the queues that zfs send worker threads
	* use to communicate. If the send_main_thread is blocking on these queues,
	* this variable may need to be increased. If there is a significant slowdown
	* at the start of a send as these threads consume all the available IO
	* resources, this variable may need to be decreased.
	*/
	int zfs_send_no_prefetch_queue_length = 1024 * 1024;
	/*
	* These tunables control the fill fraction of the queues by zfs send. The fill
	* fraction controls the frequency with which threads have to be cv_signaled.
	* If a lot of cpu time is being spent on cv_signal, then these should be tuned
	* down. If the queues empty before the signalled thread can catch up, then
	* these should be tuned up.
	*/
	int zfs_send_queue_ff = 20;
	int zfs_send_no_prefetch_queue_ff = 20;

	/*
	* Use this to override the recordsize calculation for fast zfs send estimates.
	*/
	int zfs_override_estimate_recordsize = 0;

	/* Set this tunable to FALSE to disable setting of DRR_FLAG_FREERECORDS */
	int zfs_send_set_freerecords_bit = B_TRUE;

	/* Set this tunable to FALSE is disable sending unmodified spill blocks. */
	int zfs_send_unmodified_spill_blocks = B_TRUE;

	static inline boolean_t
	overflow_multiply(uint64_t a, uint64_t b, uint64_t *c)
	{
	uint64_t temp = a * b;
	if (b != 0 && temp / b != a)
	return (B_FALSE);
	*c = temp;
	return (B_TRUE);
	}

	struct send_thread_arg {
	bqueue_t q;
	objset_t os; / Objset to traverse */
	uint64_t fromtxg; /* Traverse from this txg */
	int flags; /* flags to pass to traverse_dataset */
	int error_code;
	boolean_t cancel;
	zbookmark_phys_t resume;
	uint64_t *num_blocks_visited;
	};

	struct redact_list_thread_arg {
	boolean_t cancel;
	bqueue_t q;
	zbookmark_phys_t resume;
	redaction_list_t *rl;
	boolean_t mark_redact;
	int error_code;
	uint64_t *num_blocks_visited;
	};

	struct send_merge_thread_arg {
	bqueue_t q;
	objset_t *os;
	struct redact_list_thread_arg *from_arg;
	struct send_thread_arg *to_arg;
	struct redact_list_thread_arg *redact_arg;
	int error;
	boolean_t cancel;
	};

	struct send_range {
	boolean_t eos_marker; /* Marks the end of the stream */
	uint64_t object;
	uint64_t start_blkid;
	uint64_t end_blkid;
	bqueue_node_t ln;
	enum type {DATA, HOLE, OBJECT, OBJECT_RANGE, REDACT,
	PREVIOUSLY_REDACTED} type;
	union {
	struct srd {
	dmu_object_type_t obj_type;
	uint32_t datablksz; // logical size
	uint32_t datasz; // payload size
	blkptr_t bp;
	arc_buf_t *abuf;
	abd_t *abd;
	kmutex_t lock;
	kcondvar_t cv;
	boolean_t io_outstanding;
	+ boolean_t io_compressed;
	int io_err;
	} data;
	struct srh {
	uint32_t datablksz;
	} hole;
	struct sro {
	/*
	* This is a pointer because embedding it in the
	* struct causes these structures to be massively larger
	* for all range types; this makes the code much less
	* memory efficient.
	*/
	dnode_phys_t *dnp;
	blkptr_t bp;
	} object;
	struct srr {
	uint32_t datablksz;
	} redact;
	struct sror {
	blkptr_t bp;
	} object_range;
	} sru;
	};

	/*
	* The list of data whose inclusion in a send stream can be pending from
	* one call to backup_cb to another. Multiple calls to dump_free(),
	* dump_freeobjects(), and dump_redact() can be aggregated into a single
	* DRR_FREE, DRR_FREEOBJECTS, or DRR_REDACT replay record.
	*/
	typedef enum {
	PENDING_NONE,
	PENDING_FREE,
	PENDING_FREEOBJECTS,
	PENDING_REDACT
	} dmu_pendop_t;

	typedef struct dmu_send_cookie {
	dmu_replay_record_t *dsc_drr;
	dmu_send_outparams_t *dsc_dso;
	offset_t *dsc_off;
	objset_t *dsc_os;
	zio_cksum_t dsc_zc;
	uint64_t dsc_toguid;
	uint64_t dsc_fromtxg;
	int dsc_err;
	dmu_pendop_t dsc_pending_op;
	uint64_t dsc_featureflags;
	uint64_t dsc_last_data_object;
	uint64_t dsc_last_data_offset;
	uint64_t dsc_resume_object;
	uint64_t dsc_resume_offset;
	boolean_t dsc_sent_begin;
	boolean_t dsc_sent_end;
	} dmu_send_cookie_t;

	static int do_dump(dmu_send_cookie_t dscp, struct send_range range);

	static void
	range_free(struct send_range *range)
	{
	if (range->type == OBJECT) {
	size_t size = sizeof (dnode_phys_t) *
	(range->sru.object.dnp->dn_extra_slots + 1);
	kmem_free(range->sru.object.dnp, size);
	} else if (range->type == DATA) {
	mutex_enter(&range->sru.data.lock);
	while (range->sru.data.io_outstanding)
	cv_wait(&range->sru.data.cv, &range->sru.data.lock);
	if (range->sru.data.abd != NULL)
	abd_free(range->sru.data.abd);
	if (range->sru.data.abuf != NULL) {
	arc_buf_destroy(range->sru.data.abuf,
	&range->sru.data.abuf);
	}
	mutex_exit(&range->sru.data.lock);

	cv_destroy(&range->sru.data.cv);
	mutex_destroy(&range->sru.data.lock);
	}
	kmem_free(range, sizeof (*range));
	}

	/*
	* For all record types except BEGIN, fill in the checksum (overlaid in
	* drr_u.drr_checksum.drr_checksum). The checksum verifies everything
	* up to the start of the checksum itself.
	*/
	static int
	dump_record(dmu_send_cookie_t dscp, void payload, int payload_len)
	{
	dmu_send_outparams_t *dso = dscp->dsc_dso;
	ASSERT3U(offsetof(dmu_replay_record_t, drr_u.drr_checksum.drr_checksum),
	==, sizeof (dmu_replay_record_t) - sizeof (zio_cksum_t));
	(void) fletcher_4_incremental_native(dscp->dsc_drr,
	offsetof(dmu_replay_record_t, drr_u.drr_checksum.drr_checksum),
	&dscp->dsc_zc);
	if (dscp->dsc_drr->drr_type == DRR_BEGIN) {
	dscp->dsc_sent_begin = B_TRUE;
	} else {
	ASSERT(ZIO_CHECKSUM_IS_ZERO(&dscp->dsc_drr->drr_u.
	drr_checksum.drr_checksum));
	dscp->dsc_drr->drr_u.drr_checksum.drr_checksum = dscp->dsc_zc;
	}
	if (dscp->dsc_drr->drr_type == DRR_END) {
	dscp->dsc_sent_end = B_TRUE;
	}
	(void) fletcher_4_incremental_native(&dscp->dsc_drr->
	drr_u.drr_checksum.drr_checksum,
	sizeof (zio_cksum_t), &dscp->dsc_zc);
	*dscp->dsc_off += sizeof (dmu_replay_record_t);
	dscp->dsc_err = dso->dso_outfunc(dscp->dsc_os, dscp->dsc_drr,
	sizeof (dmu_replay_record_t), dso->dso_arg);
	if (dscp->dsc_err != 0)
	return (SET_ERROR(EINTR));
	if (payload_len != 0) {
	*dscp->dsc_off += payload_len;
	/*
	* payload is null when dso_dryrun == B_TRUE (i.e. when we're
	* doing a send size calculation)
	*/
	if (payload != NULL) {
	(void) fletcher_4_incremental_native(
	payload, payload_len, &dscp->dsc_zc);
	}

	/*
	* The code does not rely on this (len being a multiple of 8).
	* We keep this assertion because of the corresponding assertion
	* in receive_read(). Keeping this assertion ensures that we do
	* not inadvertently break backwards compatibility (causing the
	* assertion in receive_read() to trigger on old software).
	*
	* Raw sends cannot be received on old software, and so can
	* bypass this assertion.
	*/

	ASSERT((payload_len % 8 == 0) \|\|
	(dscp->dsc_featureflags & DMU_BACKUP_FEATURE_RAW));

	dscp->dsc_err = dso->dso_outfunc(dscp->dsc_os, payload,
	payload_len, dso->dso_arg);
	if (dscp->dsc_err != 0)
	return (SET_ERROR(EINTR));
	}
	return (0);
	}

	/*
	* Fill in the drr_free struct, or perform aggregation if the previous record is
	* also a free record, and the two are adjacent.
	*
	* Note that we send free records even for a full send, because we want to be
	* able to receive a full send as a clone, which requires a list of all the free
	* and freeobject records that were generated on the source.
	*/
	static int
	dump_free(dmu_send_cookie_t *dscp, uint64_t object, uint64_t offset,
	uint64_t length)
	{
	struct drr_free *drrf = &(dscp->dsc_drr->drr_u.drr_free);

	/*
	* When we receive a free record, dbuf_free_range() assumes
	* that the receiving system doesn't have any dbufs in the range
	* being freed. This is always true because there is a one-record
	* constraint: we only send one WRITE record for any given
	* object,offset. We know that the one-record constraint is
	* true because we always send data in increasing order by
	* object,offset.
	*
	* If the increasing-order constraint ever changes, we should find
	* another way to assert that the one-record constraint is still
	* satisfied.
	*/
	ASSERT(object > dscp->dsc_last_data_object \|\|
	(object == dscp->dsc_last_data_object &&
	offset > dscp->dsc_last_data_offset));

	/*
	* If there is a pending op, but it's not PENDING_FREE, push it out,
	* since free block aggregation can only be done for blocks of the
	* same type (i.e., DRR_FREE records can only be aggregated with
	* other DRR_FREE records. DRR_FREEOBJECTS records can only be
	* aggregated with other DRR_FREEOBJECTS records).
	*/
	if (dscp->dsc_pending_op != PENDING_NONE &&
	dscp->dsc_pending_op != PENDING_FREE) {
	if (dump_record(dscp, NULL, 0) != 0)
	return (SET_ERROR(EINTR));
	dscp->dsc_pending_op = PENDING_NONE;
	}

	if (dscp->dsc_pending_op == PENDING_FREE) {
	/*
	* Check to see whether this free block can be aggregated
	* with pending one.
	*/
	if (drrf->drr_object == object && drrf->drr_offset +
	drrf->drr_length == offset) {
	if (offset + length < offset \|\| length == UINT64_MAX)
	drrf->drr_length = UINT64_MAX;
	else
	drrf->drr_length += length;
	return (0);
	} else {
	/* not a continuation. Push out pending record */
	if (dump_record(dscp, NULL, 0) != 0)
	return (SET_ERROR(EINTR));
	dscp->dsc_pending_op = PENDING_NONE;
	}
	}
	/* create a FREE record and make it pending */
	bzero(dscp->dsc_drr, sizeof (dmu_replay_record_t));
	dscp->dsc_drr->drr_type = DRR_FREE;
	drrf->drr_object = object;
	drrf->drr_offset = offset;
	if (offset + length < offset)
	drrf->drr_length = DMU_OBJECT_END;
	else
	drrf->drr_length = length;
	drrf->drr_toguid = dscp->dsc_toguid;
	if (length == DMU_OBJECT_END) {
	if (dump_record(dscp, NULL, 0) != 0)
	return (SET_ERROR(EINTR));
	} else {
	dscp->dsc_pending_op = PENDING_FREE;
	}

	return (0);
	}

	/*
	* Fill in the drr_redact struct, or perform aggregation if the previous record
	* is also a redaction record, and the two are adjacent.
	*/
	static int
	dump_redact(dmu_send_cookie_t *dscp, uint64_t object, uint64_t offset,
	uint64_t length)
	{
	struct drr_redact *drrr = &dscp->dsc_drr->drr_u.drr_redact;

	/*
	* If there is a pending op, but it's not PENDING_REDACT, push it out,
	* since free block aggregation can only be done for blocks of the
	* same type (i.e., DRR_REDACT records can only be aggregated with
	* other DRR_REDACT records).
	*/
	if (dscp->dsc_pending_op != PENDING_NONE &&
	dscp->dsc_pending_op != PENDING_REDACT) {
	if (dump_record(dscp, NULL, 0) != 0)
	return (SET_ERROR(EINTR));
	dscp->dsc_pending_op = PENDING_NONE;
	}

	if (dscp->dsc_pending_op == PENDING_REDACT) {
	/*
	* Check to see whether this redacted block can be aggregated
	* with pending one.
	*/
	if (drrr->drr_object == object && drrr->drr_offset +
	drrr->drr_length == offset) {
	drrr->drr_length += length;
	return (0);
	} else {
	/* not a continuation. Push out pending record */
	if (dump_record(dscp, NULL, 0) != 0)
	return (SET_ERROR(EINTR));
	dscp->dsc_pending_op = PENDING_NONE;
	}
	}
	/* create a REDACT record and make it pending */
	bzero(dscp->dsc_drr, sizeof (dmu_replay_record_t));
	dscp->dsc_drr->drr_type = DRR_REDACT;
	drrr->drr_object = object;
	drrr->drr_offset = offset;
	drrr->drr_length = length;
	drrr->drr_toguid = dscp->dsc_toguid;
	dscp->dsc_pending_op = PENDING_REDACT;

	return (0);
	}

	static int
	dmu_dump_write(dmu_send_cookie_t *dscp, dmu_object_type_t type, uint64_t object,
	- uint64_t offset, int lsize, int psize, const blkptr_t bp, void data)
	+ uint64_t offset, int lsize, int psize, const blkptr_t *bp,
	+ boolean_t io_compressed, void *data)
	{
	uint64_t payload_size;
	boolean_t raw = (dscp->dsc_featureflags & DMU_BACKUP_FEATURE_RAW);
	struct drr_write *drrw = &(dscp->dsc_drr->drr_u.drr_write);

	/*
	* We send data in increasing object, offset order.
	* See comment in dump_free() for details.
	*/
	ASSERT(object > dscp->dsc_last_data_object \|\|
	(object == dscp->dsc_last_data_object &&
	offset > dscp->dsc_last_data_offset));
	dscp->dsc_last_data_object = object;
	dscp->dsc_last_data_offset = offset + lsize - 1;

	/*
	* If there is any kind of pending aggregation (currently either
	* a grouping of free objects or free blocks), push it out to
	* the stream, since aggregation can't be done across operations
	* of different types.
	*/
	if (dscp->dsc_pending_op != PENDING_NONE) {
	if (dump_record(dscp, NULL, 0) != 0)
	return (SET_ERROR(EINTR));
	dscp->dsc_pending_op = PENDING_NONE;
	}
	/* write a WRITE record */
	bzero(dscp->dsc_drr, sizeof (dmu_replay_record_t));
	dscp->dsc_drr->drr_type = DRR_WRITE;
	drrw->drr_object = object;
	drrw->drr_type = type;
	drrw->drr_offset = offset;
	drrw->drr_toguid = dscp->dsc_toguid;
	drrw->drr_logical_size = lsize;

	/* only set the compression fields if the buf is compressed or raw */
	- if (raw \|\| lsize != psize) {
	+ boolean_t compressed =
	+ (bp != NULL ? BP_GET_COMPRESS(bp) != ZIO_COMPRESS_OFF &&
	+ io_compressed : lsize != psize);
	+ if (raw \|\| compressed) {
	ASSERT(raw \|\| dscp->dsc_featureflags &
	DMU_BACKUP_FEATURE_COMPRESSED);
	ASSERT(!BP_IS_EMBEDDED(bp));
	ASSERT3S(psize, >, 0);

	if (raw) {
	ASSERT(BP_IS_PROTECTED(bp));

	/*
	* This is a raw protected block so we need to pass
	* along everything the receiving side will need to
	* interpret this block, including the byteswap, salt,
	* IV, and MAC.
	*/
	if (BP_SHOULD_BYTESWAP(bp))
	drrw->drr_flags \|= DRR_RAW_BYTESWAP;
	zio_crypt_decode_params_bp(bp, drrw->drr_salt,
	drrw->drr_iv);
	zio_crypt_decode_mac_bp(bp, drrw->drr_mac);
	} else {
	/* this is a compressed block */
	ASSERT(dscp->dsc_featureflags &
	DMU_BACKUP_FEATURE_COMPRESSED);
	ASSERT(!BP_SHOULD_BYTESWAP(bp));
	ASSERT(!DMU_OT_IS_METADATA(BP_GET_TYPE(bp)));
	ASSERT3U(BP_GET_COMPRESS(bp), !=, ZIO_COMPRESS_OFF);
	ASSERT3S(lsize, >=, psize);
	}

	/* set fields common to compressed and raw sends */
	drrw->drr_compressiontype = BP_GET_COMPRESS(bp);
	drrw->drr_compressed_size = psize;
	payload_size = drrw->drr_compressed_size;
	} else {
	payload_size = drrw->drr_logical_size;
	}

	if (bp == NULL \|\| BP_IS_EMBEDDED(bp) \|\| (BP_IS_PROTECTED(bp) && !raw)) {
	/*
	* There's no pre-computed checksum for partial-block writes,
	* embedded BP's, or encrypted BP's that are being sent as
	* plaintext, so (like fletcher4-checksummed blocks) userland
	* will have to compute a dedup-capable checksum itself.
	*/
	drrw->drr_checksumtype = ZIO_CHECKSUM_OFF;
	} else {
	drrw->drr_checksumtype = BP_GET_CHECKSUM(bp);
	if (zio_checksum_table[drrw->drr_checksumtype].ci_flags &
	ZCHECKSUM_FLAG_DEDUP)
	drrw->drr_flags \|= DRR_CHECKSUM_DEDUP;
	DDK_SET_LSIZE(&drrw->drr_key, BP_GET_LSIZE(bp));
	DDK_SET_PSIZE(&drrw->drr_key, BP_GET_PSIZE(bp));
	DDK_SET_COMPRESS(&drrw->drr_key, BP_GET_COMPRESS(bp));
	DDK_SET_CRYPT(&drrw->drr_key, BP_IS_PROTECTED(bp));
	drrw->drr_key.ddk_cksum = bp->blk_cksum;
	}

	if (dump_record(dscp, data, payload_size) != 0)
	return (SET_ERROR(EINTR));
	return (0);
	}

	static int
	dump_write_embedded(dmu_send_cookie_t *dscp, uint64_t object, uint64_t offset,
	int blksz, const blkptr_t *bp)
	{
	char buf[BPE_PAYLOAD_SIZE];
	struct drr_write_embedded *drrw =
	&(dscp->dsc_drr->drr_u.drr_write_embedded);

	if (dscp->dsc_pending_op != PENDING_NONE) {
	if (dump_record(dscp, NULL, 0) != 0)
	return (SET_ERROR(EINTR));
	dscp->dsc_pending_op = PENDING_NONE;
	}

	ASSERT(BP_IS_EMBEDDED(bp));

	bzero(dscp->dsc_drr, sizeof (dmu_replay_record_t));
	dscp->dsc_drr->drr_type = DRR_WRITE_EMBEDDED;
	drrw->drr_object = object;
	drrw->drr_offset = offset;
	drrw->drr_length = blksz;
	drrw->drr_toguid = dscp->dsc_toguid;
	drrw->drr_compression = BP_GET_COMPRESS(bp);
	drrw->drr_etype = BPE_GET_ETYPE(bp);
	drrw->drr_lsize = BPE_GET_LSIZE(bp);
	drrw->drr_psize = BPE_GET_PSIZE(bp);

	decode_embedded_bp_compressed(bp, buf);

	if (dump_record(dscp, buf, P2ROUNDUP(drrw->drr_psize, 8)) != 0)
	return (SET_ERROR(EINTR));
	return (0);
	}

	static int
	dump_spill(dmu_send_cookie_t dscp, const blkptr_t bp, uint64_t object,
	void *data)
	{
	struct drr_spill *drrs = &(dscp->dsc_drr->drr_u.drr_spill);
	uint64_t blksz = BP_GET_LSIZE(bp);
	uint64_t payload_size = blksz;

	if (dscp->dsc_pending_op != PENDING_NONE) {
	if (dump_record(dscp, NULL, 0) != 0)
	return (SET_ERROR(EINTR));
	dscp->dsc_pending_op = PENDING_NONE;
	}

	/* write a SPILL record */
	bzero(dscp->dsc_drr, sizeof (dmu_replay_record_t));
	dscp->dsc_drr->drr_type = DRR_SPILL;
	drrs->drr_object = object;
	drrs->drr_length = blksz;
	drrs->drr_toguid = dscp->dsc_toguid;

	/* See comment in dump_dnode() for full details */
	if (zfs_send_unmodified_spill_blocks &&
	(bp->blk_birth <= dscp->dsc_fromtxg)) {
	drrs->drr_flags \|= DRR_SPILL_UNMODIFIED;
	}

	/* handle raw send fields */
	if (dscp->dsc_featureflags & DMU_BACKUP_FEATURE_RAW) {
	ASSERT(BP_IS_PROTECTED(bp));

	if (BP_SHOULD_BYTESWAP(bp))
	drrs->drr_flags \|= DRR_RAW_BYTESWAP;
	drrs->drr_compressiontype = BP_GET_COMPRESS(bp);
	drrs->drr_compressed_size = BP_GET_PSIZE(bp);
	zio_crypt_decode_params_bp(bp, drrs->drr_salt, drrs->drr_iv);
	zio_crypt_decode_mac_bp(bp, drrs->drr_mac);
	payload_size = drrs->drr_compressed_size;
	}

	if (dump_record(dscp, data, payload_size) != 0)
	return (SET_ERROR(EINTR));
	return (0);
	}

	static int
	dump_freeobjects(dmu_send_cookie_t *dscp, uint64_t firstobj, uint64_t numobjs)
	{
	struct drr_freeobjects *drrfo = &(dscp->dsc_drr->drr_u.drr_freeobjects);
	uint64_t maxobj = DNODES_PER_BLOCK *
	(DMU_META_DNODE(dscp->dsc_os)->dn_maxblkid + 1);

	/*
	* ZoL < 0.7 does not handle large FREEOBJECTS records correctly,
	* leading to zfs recv never completing. to avoid this issue, don't
	* send FREEOBJECTS records for object IDs which cannot exist on the
	* receiving side.
	*/
	if (maxobj > 0) {
	if (maxobj <= firstobj)
	return (0);

	if (maxobj < firstobj + numobjs)
	numobjs = maxobj - firstobj;
	}

	/*
	* If there is a pending op, but it's not PENDING_FREEOBJECTS,
	* push it out, since free block aggregation can only be done for
	* blocks of the same type (i.e., DRR_FREE records can only be
	* aggregated with other DRR_FREE records. DRR_FREEOBJECTS records
	* can only be aggregated with other DRR_FREEOBJECTS records).
	*/
	if (dscp->dsc_pending_op != PENDING_NONE &&
	dscp->dsc_pending_op != PENDING_FREEOBJECTS) {
	if (dump_record(dscp, NULL, 0) != 0)
	return (SET_ERROR(EINTR));
	dscp->dsc_pending_op = PENDING_NONE;
	}

	if (dscp->dsc_pending_op == PENDING_FREEOBJECTS) {
	/*
	* See whether this free object array can be aggregated
	* with pending one
	*/
	if (drrfo->drr_firstobj + drrfo->drr_numobjs == firstobj) {
	drrfo->drr_numobjs += numobjs;
	return (0);
	} else {
	/* can't be aggregated. Push out pending record */
	if (dump_record(dscp, NULL, 0) != 0)
	return (SET_ERROR(EINTR));
	dscp->dsc_pending_op = PENDING_NONE;
	}
	}

	/* write a FREEOBJECTS record */
	bzero(dscp->dsc_drr, sizeof (dmu_replay_record_t));
	dscp->dsc_drr->drr_type = DRR_FREEOBJECTS;
	drrfo->drr_firstobj = firstobj;
	drrfo->drr_numobjs = numobjs;
	drrfo->drr_toguid = dscp->dsc_toguid;

	dscp->dsc_pending_op = PENDING_FREEOBJECTS;

	return (0);
	}

	static int
	dump_dnode(dmu_send_cookie_t dscp, const blkptr_t bp, uint64_t object,
	dnode_phys_t *dnp)
	{
	struct drr_object *drro = &(dscp->dsc_drr->drr_u.drr_object);
	int bonuslen;

	if (object < dscp->dsc_resume_object) {
	/*
	* Note: when resuming, we will visit all the dnodes in
	* the block of dnodes that we are resuming from. In
	* this case it's unnecessary to send the dnodes prior to
	* the one we are resuming from. We should be at most one
	* block's worth of dnodes behind the resume point.
	*/
	ASSERT3U(dscp->dsc_resume_object - object, <,
	1 << (DNODE_BLOCK_SHIFT - DNODE_SHIFT));
	return (0);
	}

	if (dnp == NULL \|\| dnp->dn_type == DMU_OT_NONE)
	return (dump_freeobjects(dscp, object, 1));

	if (dscp->dsc_pending_op != PENDING_NONE) {
	if (dump_record(dscp, NULL, 0) != 0)
	return (SET_ERROR(EINTR));
	dscp->dsc_pending_op = PENDING_NONE;
	}

	/* write an OBJECT record */
	bzero(dscp->dsc_drr, sizeof (dmu_replay_record_t));
	dscp->dsc_drr->drr_type = DRR_OBJECT;
	drro->drr_object = object;
	drro->drr_type = dnp->dn_type;
	drro->drr_bonustype = dnp->dn_bonustype;
	drro->drr_blksz = dnp->dn_datablkszsec << SPA_MINBLOCKSHIFT;
	drro->drr_bonuslen = dnp->dn_bonuslen;
	drro->drr_dn_slots = dnp->dn_extra_slots + 1;
	drro->drr_checksumtype = dnp->dn_checksum;
	drro->drr_compress = dnp->dn_compress;
	drro->drr_toguid = dscp->dsc_toguid;

	if (!(dscp->dsc_featureflags & DMU_BACKUP_FEATURE_LARGE_BLOCKS) &&
	drro->drr_blksz > SPA_OLD_MAXBLOCKSIZE)
	drro->drr_blksz = SPA_OLD_MAXBLOCKSIZE;

	bonuslen = P2ROUNDUP(dnp->dn_bonuslen, 8);

	if ((dscp->dsc_featureflags & DMU_BACKUP_FEATURE_RAW)) {
	ASSERT(BP_IS_ENCRYPTED(bp));

	if (BP_SHOULD_BYTESWAP(bp))
	drro->drr_flags \|= DRR_RAW_BYTESWAP;

	/* needed for reconstructing dnp on recv side */
	drro->drr_maxblkid = dnp->dn_maxblkid;
	drro->drr_indblkshift = dnp->dn_indblkshift;
	drro->drr_nlevels = dnp->dn_nlevels;
	drro->drr_nblkptr = dnp->dn_nblkptr;

	/*
	* Since we encrypt the entire bonus area, the (raw) part
	* beyond the bonuslen is actually nonzero, so we need
	* to send it.
	*/
	if (bonuslen != 0) {
	drro->drr_raw_bonuslen = DN_MAX_BONUS_LEN(dnp);
	bonuslen = drro->drr_raw_bonuslen;
	}
	}

	/*
	* DRR_OBJECT_SPILL is set for every dnode which references a
	* spill block. This allows the receiving pool to definitively
	* determine when a spill block should be kept or freed.
	*/
	if (dnp->dn_flags & DNODE_FLAG_SPILL_BLKPTR)
	drro->drr_flags \|= DRR_OBJECT_SPILL;

	if (dump_record(dscp, DN_BONUS(dnp), bonuslen) != 0)
	return (SET_ERROR(EINTR));

	/* Free anything past the end of the file. */
	if (dump_free(dscp, object, (dnp->dn_maxblkid + 1) *
	(dnp->dn_datablkszsec << SPA_MINBLOCKSHIFT), DMU_OBJECT_END) != 0)
	return (SET_ERROR(EINTR));

	/*
	* Send DRR_SPILL records for unmodified spill blocks. This is useful
	* because changing certain attributes of the object (e.g. blocksize)
	* can cause old versions of ZFS to incorrectly remove a spill block.
	* Including these records in the stream forces an up to date version
	* to always be written ensuring they're never lost. Current versions
	* of the code which understand the DRR_FLAG_SPILL_BLOCK feature can
	* ignore these unmodified spill blocks.
	*/
	if (zfs_send_unmodified_spill_blocks &&
	(dnp->dn_flags & DNODE_FLAG_SPILL_BLKPTR) &&
	(DN_SPILL_BLKPTR(dnp)->blk_birth <= dscp->dsc_fromtxg)) {
	struct send_range record;
	blkptr_t *bp = DN_SPILL_BLKPTR(dnp);

	bzero(&record, sizeof (struct send_range));
	record.type = DATA;
	record.object = object;
	record.eos_marker = B_FALSE;
	record.start_blkid = DMU_SPILL_BLKID;
	record.end_blkid = record.start_blkid + 1;
	record.sru.data.bp = *bp;
	record.sru.data.obj_type = dnp->dn_type;
	record.sru.data.datablksz = BP_GET_LSIZE(bp);

	if (do_dump(dscp, &record) != 0)
	return (SET_ERROR(EINTR));
	}

	if (dscp->dsc_err != 0)
	return (SET_ERROR(EINTR));

	return (0);
	}

	static int
	dump_object_range(dmu_send_cookie_t dscp, const blkptr_t bp,
	uint64_t firstobj, uint64_t numslots)
	{
	struct drr_object_range *drror =
	&(dscp->dsc_drr->drr_u.drr_object_range);

	/* we only use this record type for raw sends */
	ASSERT(BP_IS_PROTECTED(bp));
	ASSERT(dscp->dsc_featureflags & DMU_BACKUP_FEATURE_RAW);
	ASSERT3U(BP_GET_COMPRESS(bp), ==, ZIO_COMPRESS_OFF);
	ASSERT3U(BP_GET_TYPE(bp), ==, DMU_OT_DNODE);
	ASSERT0(BP_GET_LEVEL(bp));

	if (dscp->dsc_pending_op != PENDING_NONE) {
	if (dump_record(dscp, NULL, 0) != 0)
	return (SET_ERROR(EINTR));
	dscp->dsc_pending_op = PENDING_NONE;
	}

	bzero(dscp->dsc_drr, sizeof (dmu_replay_record_t));
	dscp->dsc_drr->drr_type = DRR_OBJECT_RANGE;
	drror->drr_firstobj = firstobj;
	drror->drr_numslots = numslots;
	drror->drr_toguid = dscp->dsc_toguid;
	if (BP_SHOULD_BYTESWAP(bp))
	drror->drr_flags \|= DRR_RAW_BYTESWAP;
	zio_crypt_decode_params_bp(bp, drror->drr_salt, drror->drr_iv);
	zio_crypt_decode_mac_bp(bp, drror->drr_mac);

	if (dump_record(dscp, NULL, 0) != 0)
	return (SET_ERROR(EINTR));
	return (0);
	}

	static boolean_t
	send_do_embed(const blkptr_t *bp, uint64_t featureflags)
	{
	if (!BP_IS_EMBEDDED(bp))
	return (B_FALSE);

	/*
	* Compression function must be legacy, or explicitly enabled.
	*/
	if ((BP_GET_COMPRESS(bp) >= ZIO_COMPRESS_LEGACY_FUNCTIONS &&
	!(featureflags & DMU_BACKUP_FEATURE_LZ4)))
	return (B_FALSE);

	/*
	* If we have not set the ZSTD feature flag, we can't send ZSTD
	* compressed embedded blocks, as the receiver may not support them.
	*/
	if ((BP_GET_COMPRESS(bp) == ZIO_COMPRESS_ZSTD &&
	!(featureflags & DMU_BACKUP_FEATURE_ZSTD)))
	return (B_FALSE);

	/*
	* Embed type must be explicitly enabled.
	*/
	switch (BPE_GET_ETYPE(bp)) {
	case BP_EMBEDDED_TYPE_DATA:
	if (featureflags & DMU_BACKUP_FEATURE_EMBED_DATA)
	return (B_TRUE);
	break;
	default:
	return (B_FALSE);
	}
	return (B_FALSE);
	}

	/*
	* This function actually handles figuring out what kind of record needs to be
	* dumped, and calling the appropriate helper function. In most cases,
	* the data has already been read by send_reader_thread().
	*/
	static int
	do_dump(dmu_send_cookie_t dscp, struct send_range range)
	{
	int err = 0;
	switch (range->type) {
	case OBJECT:
	err = dump_dnode(dscp, &range->sru.object.bp, range->object,
	range->sru.object.dnp);
	return (err);
	case OBJECT_RANGE: {
	ASSERT3U(range->start_blkid + 1, ==, range->end_blkid);
	if (!(dscp->dsc_featureflags & DMU_BACKUP_FEATURE_RAW)) {
	return (0);
	}
	uint64_t epb = BP_GET_LSIZE(&range->sru.object_range.bp) >>
	DNODE_SHIFT;
	uint64_t firstobj = range->start_blkid * epb;
	err = dump_object_range(dscp, &range->sru.object_range.bp,
	firstobj, epb);
	break;
	}
	case REDACT: {
	struct srr *srrp = &range->sru.redact;
	err = dump_redact(dscp, range->object, range->start_blkid *
	srrp->datablksz, (range->end_blkid - range->start_blkid) *
	srrp->datablksz);
	return (err);
	}
	case DATA: {
	struct srd *srdp = &range->sru.data;
	blkptr_t *bp = &srdp->bp;
	spa_t *spa =
	dmu_objset_spa(dscp->dsc_os);

	ASSERT3U(srdp->datablksz, ==, BP_GET_LSIZE(bp));
	ASSERT3U(range->start_blkid + 1, ==, range->end_blkid);
	if (BP_GET_TYPE(bp) == DMU_OT_SA) {
	arc_flags_t aflags = ARC_FLAG_WAIT;
	enum zio_flag zioflags = ZIO_FLAG_CANFAIL;

	if (dscp->dsc_featureflags & DMU_BACKUP_FEATURE_RAW) {
	ASSERT(BP_IS_PROTECTED(bp));
	zioflags \|= ZIO_FLAG_RAW;
	}

	zbookmark_phys_t zb;
	ASSERT3U(range->start_blkid, ==, DMU_SPILL_BLKID);
	zb.zb_objset = dmu_objset_id(dscp->dsc_os);
	zb.zb_object = range->object;
	zb.zb_level = 0;
	zb.zb_blkid = range->start_blkid;

	arc_buf_t *abuf = NULL;
	if (!dscp->dsc_dso->dso_dryrun && arc_read(NULL, spa,
	bp, arc_getbuf_func, &abuf, ZIO_PRIORITY_ASYNC_READ,
	zioflags, &aflags, &zb) != 0)
	return (SET_ERROR(EIO));

	err = dump_spill(dscp, bp, zb.zb_object,
	(abuf == NULL ? NULL : abuf->b_data));
	if (abuf != NULL)
	arc_buf_destroy(abuf, &abuf);
	return (err);
	}
	if (send_do_embed(bp, dscp->dsc_featureflags)) {
	err = dump_write_embedded(dscp, range->object,
	range->start_blkid * srdp->datablksz,
	srdp->datablksz, bp);
	return (err);
	}
	ASSERT(range->object > dscp->dsc_resume_object \|\|
	(range->object == dscp->dsc_resume_object &&
	range->start_blkid * srdp->datablksz >=
	dscp->dsc_resume_offset));
	/* it's a level-0 block of a regular object */

	mutex_enter(&srdp->lock);
	while (srdp->io_outstanding)
	cv_wait(&srdp->cv, &srdp->lock);
	err = srdp->io_err;
	mutex_exit(&srdp->lock);

	if (err != 0) {
	if (zfs_send_corrupt_data &&
	!dscp->dsc_dso->dso_dryrun) {
	/*
	* Send a block filled with 0x"zfs badd bloc"
	*/
	srdp->abuf = arc_alloc_buf(spa, &srdp->abuf,
	ARC_BUFC_DATA, srdp->datablksz);
	uint64_t *ptr;
	for (ptr = srdp->abuf->b_data;
	(char )ptr < (char )srdp->abuf->b_data +
	srdp->datablksz; ptr++)
	*ptr = 0x2f5baddb10cULL;
	} else {
	return (SET_ERROR(EIO));
	}
	}

	ASSERT(dscp->dsc_dso->dso_dryrun \|\|
	srdp->abuf != NULL \|\| srdp->abd != NULL);

	uint64_t offset = range->start_blkid * srdp->datablksz;

	char *data = NULL;
	if (srdp->abd != NULL) {
	data = abd_to_buf(srdp->abd);
	ASSERT3P(srdp->abuf, ==, NULL);
	} else if (srdp->abuf != NULL) {
	data = srdp->abuf->b_data;
	}

	/*
	* If we have large blocks stored on disk but the send flags
	* don't allow us to send large blocks, we split the data from
	* the arc buf into chunks.
	*/
	if (srdp->datablksz > SPA_OLD_MAXBLOCKSIZE &&
	!(dscp->dsc_featureflags &
	DMU_BACKUP_FEATURE_LARGE_BLOCKS)) {
	while (srdp->datablksz > 0 && err == 0) {
	int n = MIN(srdp->datablksz,
	SPA_OLD_MAXBLOCKSIZE);
	err = dmu_dump_write(dscp, srdp->obj_type,
	- range->object, offset, n, n, NULL, data);
	+ range->object, offset, n, n, NULL, B_FALSE,
	+ data);
	offset += n;
	/*
	* When doing dry run, data==NULL is used as a
	* sentinel value by
	* dmu_dump_write()->dump_record().
	*/
	if (data != NULL)
	data += n;
	srdp->datablksz -= n;
	}
	} else {
	err = dmu_dump_write(dscp, srdp->obj_type,
	range->object, offset,
	- srdp->datablksz, srdp->datasz, bp, data);
	+ srdp->datablksz, srdp->datasz, bp,
	+ srdp->io_compressed, data);
	}
	return (err);
	}
	case HOLE: {
	struct srh *srhp = &range->sru.hole;
	if (range->object == DMU_META_DNODE_OBJECT) {
	uint32_t span = srhp->datablksz >> DNODE_SHIFT;
	uint64_t first_obj = range->start_blkid * span;
	uint64_t numobj = range->end_blkid * span - first_obj;
	return (dump_freeobjects(dscp, first_obj, numobj));
	}
	uint64_t offset = 0;

	/*
	* If this multiply overflows, we don't need to send this block.
	* Even if it has a birth time, it can never not be a hole, so
	* we don't need to send records for it.
	*/
	if (!overflow_multiply(range->start_blkid, srhp->datablksz,
	&offset)) {
	return (0);
	}
	uint64_t len = 0;

	if (!overflow_multiply(range->end_blkid, srhp->datablksz, &len))
	len = UINT64_MAX;
	len = len - offset;
	return (dump_free(dscp, range->object, offset, len));
	}
	default:
	panic("Invalid range type in do_dump: %d", range->type);
	}
	return (err);
	}

	static struct send_range *
	range_alloc(enum type type, uint64_t object, uint64_t start_blkid,
	uint64_t end_blkid, boolean_t eos)
	{
	struct send_range range = kmem_alloc(sizeof (range), KM_SLEEP);
	range->type = type;
	range->object = object;
	range->start_blkid = start_blkid;
	range->end_blkid = end_blkid;
	range->eos_marker = eos;
	if (type == DATA) {
	range->sru.data.abd = NULL;
	range->sru.data.abuf = NULL;
	mutex_init(&range->sru.data.lock, NULL, MUTEX_DEFAULT, NULL);
	cv_init(&range->sru.data.cv, NULL, CV_DEFAULT, NULL);
	range->sru.data.io_outstanding = 0;
	range->sru.data.io_err = 0;
	+ range->sru.data.io_compressed = B_FALSE;
	}
	return (range);
	}

	/*
	* This is the callback function to traverse_dataset that acts as a worker
	* thread for dmu_send_impl.
	*/
	/ARGSUSED/
	static int
	send_cb(spa_t spa, zilog_t zilog, const blkptr_t *bp,
	const zbookmark_phys_t zb, const struct dnode_phys dnp, void *arg)
	{
	struct send_thread_arg *sta = arg;
	struct send_range *record;

	ASSERT(zb->zb_object == DMU_META_DNODE_OBJECT \|\|
	zb->zb_object >= sta->resume.zb_object);

	/*
	* All bps of an encrypted os should have the encryption bit set.
	* If this is not true it indicates tampering and we report an error.
	*/
	if (sta->os->os_encrypted &&
	!BP_IS_HOLE(bp) && !BP_USES_CRYPT(bp)) {
	spa_log_error(spa, zb);
	zfs_panic_recover("unencrypted block in encrypted "
	"object set %llu", dmu_objset_id(sta->os));
	return (SET_ERROR(EIO));
	}

	if (sta->cancel)
	return (SET_ERROR(EINTR));
	if (zb->zb_object != DMU_META_DNODE_OBJECT &&
	DMU_OBJECT_IS_SPECIAL(zb->zb_object))
	return (0);
	atomic_inc_64(sta->num_blocks_visited);

	if (zb->zb_level == ZB_DNODE_LEVEL) {
	if (zb->zb_object == DMU_META_DNODE_OBJECT)
	return (0);
	record = range_alloc(OBJECT, zb->zb_object, 0, 0, B_FALSE);
	record->sru.object.bp = *bp;
	size_t size = sizeof (dnp) (dnp->dn_extra_slots + 1);
	record->sru.object.dnp = kmem_alloc(size, KM_SLEEP);
	bcopy(dnp, record->sru.object.dnp, size);
	bqueue_enqueue(&sta->q, record, sizeof (*record));
	return (0);
	}
	if (zb->zb_level == 0 && zb->zb_object == DMU_META_DNODE_OBJECT &&
	!BP_IS_HOLE(bp)) {
	record = range_alloc(OBJECT_RANGE, 0, zb->zb_blkid,
	zb->zb_blkid + 1, B_FALSE);
	record->sru.object_range.bp = *bp;
	bqueue_enqueue(&sta->q, record, sizeof (*record));
	return (0);
	}
	if (zb->zb_level < 0 \|\| (zb->zb_level > 0 && !BP_IS_HOLE(bp)))
	return (0);
	if (zb->zb_object == DMU_META_DNODE_OBJECT && !BP_IS_HOLE(bp))
	return (0);

	uint64_t span = bp_span_in_blocks(dnp->dn_indblkshift, zb->zb_level);
	uint64_t start;

	/*
	* If this multiply overflows, we don't need to send this block.
	* Even if it has a birth time, it can never not be a hole, so
	* we don't need to send records for it.
	*/
	if (!overflow_multiply(span, zb->zb_blkid, &start) \|\| (!(zb->zb_blkid ==
	DMU_SPILL_BLKID \|\| DMU_OT_IS_METADATA(dnp->dn_type)) &&
	span * zb->zb_blkid > dnp->dn_maxblkid)) {
	ASSERT(BP_IS_HOLE(bp));
	return (0);
	}

	if (zb->zb_blkid == DMU_SPILL_BLKID)
	ASSERT3U(BP_GET_TYPE(bp), ==, DMU_OT_SA);

	enum type record_type = DATA;
	if (BP_IS_HOLE(bp))
	record_type = HOLE;
	else if (BP_IS_REDACTED(bp))
	record_type = REDACT;
	else
	record_type = DATA;

	record = range_alloc(record_type, zb->zb_object, start,
	(start + span < start ? 0 : start + span), B_FALSE);

	uint64_t datablksz = (zb->zb_blkid == DMU_SPILL_BLKID ?
	BP_GET_LSIZE(bp) : dnp->dn_datablkszsec << SPA_MINBLOCKSHIFT);

	if (BP_IS_HOLE(bp)) {
	record->sru.hole.datablksz = datablksz;
	} else if (BP_IS_REDACTED(bp)) {
	record->sru.redact.datablksz = datablksz;
	} else {
	record->sru.data.datablksz = datablksz;
	record->sru.data.obj_type = dnp->dn_type;
	record->sru.data.bp = *bp;
	}

	bqueue_enqueue(&sta->q, record, sizeof (*record));
	return (0);
	}

	struct redact_list_cb_arg {
	uint64_t *num_blocks_visited;
	bqueue_t *q;
	boolean_t *cancel;
	boolean_t mark_redact;
	};

	static int
	redact_list_cb(redact_block_phys_t rb, void arg)
	{
	struct redact_list_cb_arg *rlcap = arg;

	atomic_inc_64(rlcap->num_blocks_visited);
	if (*rlcap->cancel)
	return (-1);

	struct send_range *data = range_alloc(REDACT, rb->rbp_object,
	rb->rbp_blkid, rb->rbp_blkid + redact_block_get_count(rb), B_FALSE);
	ASSERT3U(data->end_blkid, >, rb->rbp_blkid);
	if (rlcap->mark_redact) {
	data->type = REDACT;
	data->sru.redact.datablksz = redact_block_get_size(rb);
	} else {
	data->type = PREVIOUSLY_REDACTED;
	}
	bqueue_enqueue(rlcap->q, data, sizeof (*data));

	return (0);
	}

	/*
	* This function kicks off the traverse_dataset. It also handles setting the
	* error code of the thread in case something goes wrong, and pushes the End of
	* Stream record when the traverse_dataset call has finished.
	*/
	static void
	send_traverse_thread(void *arg)
	{
	struct send_thread_arg *st_arg = arg;
	int err = 0;
	struct send_range *data;
	fstrans_cookie_t cookie = spl_fstrans_mark();

	err = traverse_dataset_resume(st_arg->os->os_dsl_dataset,
	st_arg->fromtxg, &st_arg->resume,
	st_arg->flags, send_cb, st_arg);

	if (err != EINTR)
	st_arg->error_code = err;
	data = range_alloc(DATA, 0, 0, 0, B_TRUE);
	bqueue_enqueue_flush(&st_arg->q, data, sizeof (*data));
	spl_fstrans_unmark(cookie);
	thread_exit();
	}

	/*
	* Utility function that causes End of Stream records to compare after of all
	* others, so that other threads' comparison logic can stay simple.
	*/
	static int __attribute__((unused))
	send_range_after(const struct send_range from, const struct send_range to)
	{
	if (from->eos_marker == B_TRUE)
	return (1);
	if (to->eos_marker == B_TRUE)
	return (-1);

	uint64_t from_obj = from->object;
	uint64_t from_end_obj = from->object + 1;
	uint64_t to_obj = to->object;
	uint64_t to_end_obj = to->object + 1;
	if (from_obj == 0) {
	ASSERT(from->type == HOLE \|\| from->type == OBJECT_RANGE);
	from_obj = from->start_blkid << DNODES_PER_BLOCK_SHIFT;
	from_end_obj = from->end_blkid << DNODES_PER_BLOCK_SHIFT;
	}
	if (to_obj == 0) {
	ASSERT(to->type == HOLE \|\| to->type == OBJECT_RANGE);
	to_obj = to->start_blkid << DNODES_PER_BLOCK_SHIFT;
	to_end_obj = to->end_blkid << DNODES_PER_BLOCK_SHIFT;
	}

	if (from_end_obj <= to_obj)
	return (-1);
	if (from_obj >= to_end_obj)
	return (1);
	int64_t cmp = TREE_CMP(to->type == OBJECT_RANGE, from->type ==
	OBJECT_RANGE);
	if (unlikely(cmp))
	return (cmp);
	cmp = TREE_CMP(to->type == OBJECT, from->type == OBJECT);
	if (unlikely(cmp))
	return (cmp);
	if (from->end_blkid <= to->start_blkid)
	return (-1);
	if (from->start_blkid >= to->end_blkid)
	return (1);
	return (0);
	}

	/*
	* Pop the new data off the queue, check that the records we receive are in
	* the right order, but do not free the old data. This is used so that the
	* records can be sent on to the main thread without copying the data.
	*/
	static struct send_range *
	get_next_range_nofree(bqueue_t bq, struct send_range prev)
	{
	struct send_range *next = bqueue_dequeue(bq);
	ASSERT3S(send_range_after(prev, next), ==, -1);
	return (next);
	}

	/*
	* Pop the new data off the queue, check that the records we receive are in
	* the right order, and free the old data.
	*/
	static struct send_range *
	get_next_range(bqueue_t bq, struct send_range prev)
	{
	struct send_range *next = get_next_range_nofree(bq, prev);
	range_free(prev);
	return (next);
	}

	static void
	redact_list_thread(void *arg)
	{
	struct redact_list_thread_arg *rlt_arg = arg;
	struct send_range *record;
	fstrans_cookie_t cookie = spl_fstrans_mark();
	if (rlt_arg->rl != NULL) {
	struct redact_list_cb_arg rlcba = {0};
	rlcba.cancel = &rlt_arg->cancel;
	rlcba.q = &rlt_arg->q;
	rlcba.num_blocks_visited = rlt_arg->num_blocks_visited;
	rlcba.mark_redact = rlt_arg->mark_redact;
	int err = dsl_redaction_list_traverse(rlt_arg->rl,
	&rlt_arg->resume, redact_list_cb, &rlcba);
	if (err != EINTR)
	rlt_arg->error_code = err;
	}
	record = range_alloc(DATA, 0, 0, 0, B_TRUE);
	bqueue_enqueue_flush(&rlt_arg->q, record, sizeof (*record));
	spl_fstrans_unmark(cookie);

	thread_exit();
	}

	/*
	* Compare the start point of the two provided ranges. End of stream ranges
	* compare last, objects compare before any data or hole inside that object and
	* multi-object holes that start at the same object.
	*/
	static int
	send_range_start_compare(struct send_range r1, struct send_range r2)
	{
	uint64_t r1_objequiv = r1->object;
	uint64_t r1_l0equiv = r1->start_blkid;
	uint64_t r2_objequiv = r2->object;
	uint64_t r2_l0equiv = r2->start_blkid;
	int64_t cmp = TREE_CMP(r1->eos_marker, r2->eos_marker);
	if (unlikely(cmp))
	return (cmp);
	if (r1->object == 0) {
	r1_objequiv = r1->start_blkid * DNODES_PER_BLOCK;
	r1_l0equiv = 0;
	}
	if (r2->object == 0) {
	r2_objequiv = r2->start_blkid * DNODES_PER_BLOCK;
	r2_l0equiv = 0;
	}

	cmp = TREE_CMP(r1_objequiv, r2_objequiv);
	if (likely(cmp))
	return (cmp);
	cmp = TREE_CMP(r2->type == OBJECT_RANGE, r1->type == OBJECT_RANGE);
	if (unlikely(cmp))
	return (cmp);
	cmp = TREE_CMP(r2->type == OBJECT, r1->type == OBJECT);
	if (unlikely(cmp))
	return (cmp);

	return (TREE_CMP(r1_l0equiv, r2_l0equiv));
	}

	enum q_idx {
	REDACT_IDX = 0,
	TO_IDX,
	FROM_IDX,
	NUM_THREADS
	};

	/*
	* This function returns the next range the send_merge_thread should operate on.
	* The inputs are two arrays; the first one stores the range at the front of the
	* queues stored in the second one. The ranges are sorted in descending
	* priority order; the metadata from earlier ranges overrules metadata from
	* later ranges. out_mask is used to return which threads the ranges came from;
	* bit i is set if ranges[i] started at the same place as the returned range.
	*
	* This code is not hardcoded to compare a specific number of threads; it could
	* be used with any number, just by changing the q_idx enum.
	*
	* The "next range" is the one with the earliest start; if two starts are equal,
	* the highest-priority range is the next to operate on. If a higher-priority
	* range starts in the middle of the first range, then the first range will be
	* truncated to end where the higher-priority range starts, and we will operate
	* on that one next time. In this way, we make sure that each block covered by
	* some range gets covered by a returned range, and each block covered is
	* returned using the metadata of the highest-priority range it appears in.
	*
	* For example, if the three ranges at the front of the queues were [2,4),
	* [3,5), and [1,3), then the ranges returned would be [1,2) with the metadata
	* from the third range, [2,4) with the metadata from the first range, and then
	* [4,5) with the metadata from the second.
	*/
	static struct send_range *
	find_next_range(struct send_range ranges, bqueue_t qs, uint64_t *out_mask)
	{
	int idx = 0; // index of the range with the earliest start
	int i;
	uint64_t bmask = 0;
	for (i = 1; i < NUM_THREADS; i++) {
	if (send_range_start_compare(ranges[i], ranges[idx]) < 0)
	idx = i;
	}
	if (ranges[idx]->eos_marker) {
	struct send_range *ret = range_alloc(DATA, 0, 0, 0, B_TRUE);
	*out_mask = 0;
	return (ret);
	}
	/*
	* Find all the ranges that start at that same point.
	*/
	for (i = 0; i < NUM_THREADS; i++) {
	if (send_range_start_compare(ranges[i], ranges[idx]) == 0)
	bmask \|= 1 << i;
	}
	*out_mask = bmask;
	/*
	* OBJECT_RANGE records only come from the TO thread, and should always
	* be treated as overlapping with nothing and sent on immediately. They
	* are only used in raw sends, and are never redacted.
	*/
	if (ranges[idx]->type == OBJECT_RANGE) {
	ASSERT3U(idx, ==, TO_IDX);
	ASSERT3U(*out_mask, ==, 1 << TO_IDX);
	struct send_range *ret = ranges[idx];
	ranges[idx] = get_next_range_nofree(qs[idx], ranges[idx]);
	return (ret);
	}
	/*
	* Find the first start or end point after the start of the first range.
	*/
	uint64_t first_change = ranges[idx]->end_blkid;
	for (i = 0; i < NUM_THREADS; i++) {
	if (i == idx \|\| ranges[i]->eos_marker \|\|
	ranges[i]->object > ranges[idx]->object \|\|
	ranges[i]->object == DMU_META_DNODE_OBJECT)
	continue;
	ASSERT3U(ranges[i]->object, ==, ranges[idx]->object);
	if (first_change > ranges[i]->start_blkid &&
	(bmask & (1 << i)) == 0)
	first_change = ranges[i]->start_blkid;
	else if (first_change > ranges[i]->end_blkid)
	first_change = ranges[i]->end_blkid;
	}
	/*
	* Update all ranges to no longer overlap with the range we're
	* returning. All such ranges must start at the same place as the range
	* being returned, and end at or after first_change. Thus we update
	* their start to first_change. If that makes them size 0, then free
	* them and pull a new range from that thread.
	*/
	for (i = 0; i < NUM_THREADS; i++) {
	if (i == idx \|\| (bmask & (1 << i)) == 0)
	continue;
	ASSERT3U(first_change, >, ranges[i]->start_blkid);
	ranges[i]->start_blkid = first_change;
	ASSERT3U(ranges[i]->start_blkid, <=, ranges[i]->end_blkid);
	if (ranges[i]->start_blkid == ranges[i]->end_blkid)
	ranges[i] = get_next_range(qs[i], ranges[i]);
	}
	/*
	* Short-circuit the simple case; if the range doesn't overlap with
	* anything else, or it only overlaps with things that start at the same
	* place and are longer, send it on.
	*/
	if (first_change == ranges[idx]->end_blkid) {
	struct send_range *ret = ranges[idx];
	ranges[idx] = get_next_range_nofree(qs[idx], ranges[idx]);
	return (ret);
	}

	/*
	* Otherwise, return a truncated copy of ranges[idx] and move the start
	* of ranges[idx] back to first_change.
	*/
	struct send_range ret = kmem_alloc(sizeof (ret), KM_SLEEP);
	ret = ranges[idx];
	ret->end_blkid = first_change;
	ranges[idx]->start_blkid = first_change;
	return (ret);
	}

	#define FROM_AND_REDACT_BITS ((1 << REDACT_IDX) \| (1 << FROM_IDX))

	/*
	* Merge the results from the from thread and the to thread, and then hand the
	* records off to send_prefetch_thread to prefetch them. If this is not a
	* send from a redaction bookmark, the from thread will push an end of stream
	* record and stop, and we'll just send everything that was changed in the
	* to_ds since the ancestor's creation txg. If it is, then since
	* traverse_dataset has a canonical order, we can compare each change as
	* they're pulled off the queues. That will give us a stream that is
	* appropriately sorted, and covers all records. In addition, we pull the
	* data from the redact_list_thread and use that to determine which blocks
	* should be redacted.
	*/
	static void
	send_merge_thread(void *arg)
	{
	struct send_merge_thread_arg *smt_arg = arg;
	struct send_range *front_ranges[NUM_THREADS];
	bqueue_t *queues[NUM_THREADS];
	int err = 0;
	fstrans_cookie_t cookie = spl_fstrans_mark();

	if (smt_arg->redact_arg == NULL) {
	front_ranges[REDACT_IDX] =
	kmem_zalloc(sizeof (struct send_range), KM_SLEEP);
	front_ranges[REDACT_IDX]->eos_marker = B_TRUE;
	front_ranges[REDACT_IDX]->type = REDACT;
	queues[REDACT_IDX] = NULL;
	} else {
	front_ranges[REDACT_IDX] =
	bqueue_dequeue(&smt_arg->redact_arg->q);
	queues[REDACT_IDX] = &smt_arg->redact_arg->q;
	}
	front_ranges[TO_IDX] = bqueue_dequeue(&smt_arg->to_arg->q);
	queues[TO_IDX] = &smt_arg->to_arg->q;
	front_ranges[FROM_IDX] = bqueue_dequeue(&smt_arg->from_arg->q);
	queues[FROM_IDX] = &smt_arg->from_arg->q;
	uint64_t mask = 0;
	struct send_range *range;
	for (range = find_next_range(front_ranges, queues, &mask);
	!range->eos_marker && err == 0 && !smt_arg->cancel;
	range = find_next_range(front_ranges, queues, &mask)) {
	/*
	* If the range in question was in both the from redact bookmark
	* and the bookmark we're using to redact, then don't send it.
	* It's already redacted on the receiving system, so a redaction
	* record would be redundant.
	*/
	if ((mask & FROM_AND_REDACT_BITS) == FROM_AND_REDACT_BITS) {
	ASSERT3U(range->type, ==, REDACT);
	range_free(range);
	continue;
	}
	bqueue_enqueue(&smt_arg->q, range, sizeof (*range));

	if (smt_arg->to_arg->error_code != 0) {
	err = smt_arg->to_arg->error_code;
	} else if (smt_arg->from_arg->error_code != 0) {
	err = smt_arg->from_arg->error_code;
	} else if (smt_arg->redact_arg != NULL &&
	smt_arg->redact_arg->error_code != 0) {
	err = smt_arg->redact_arg->error_code;
	}
	}
	if (smt_arg->cancel && err == 0)
	err = SET_ERROR(EINTR);
	smt_arg->error = err;
	if (smt_arg->error != 0) {
	smt_arg->to_arg->cancel = B_TRUE;
	smt_arg->from_arg->cancel = B_TRUE;
	if (smt_arg->redact_arg != NULL)
	smt_arg->redact_arg->cancel = B_TRUE;
	}
	for (int i = 0; i < NUM_THREADS; i++) {
	while (!front_ranges[i]->eos_marker) {
	front_ranges[i] = get_next_range(queues[i],
	front_ranges[i]);
	}
	range_free(front_ranges[i]);
	}
	if (range == NULL)
	range = kmem_zalloc(sizeof (*range), KM_SLEEP);
	range->eos_marker = B_TRUE;
	bqueue_enqueue_flush(&smt_arg->q, range, 1);
	spl_fstrans_unmark(cookie);
	thread_exit();
	}

	struct send_reader_thread_arg {
	struct send_merge_thread_arg *smta;
	bqueue_t q;
	boolean_t cancel;
	boolean_t issue_reads;
	uint64_t featureflags;
	int error;
	};

	static void
	dmu_send_read_done(zio_t *zio)
	{
	struct send_range *range = zio->io_private;

	mutex_enter(&range->sru.data.lock);
	if (zio->io_error != 0) {
	abd_free(range->sru.data.abd);
	range->sru.data.abd = NULL;
	range->sru.data.io_err = zio->io_error;
	}

	ASSERT(range->sru.data.io_outstanding);
	range->sru.data.io_outstanding = B_FALSE;
	cv_broadcast(&range->sru.data.cv);
	mutex_exit(&range->sru.data.lock);
	}

	static void
	issue_data_read(struct send_reader_thread_arg srta, struct send_range range)
	{
	struct srd *srdp = &range->sru.data;
	blkptr_t *bp = &srdp->bp;
	objset_t *os = srta->smta->os;

	ASSERT3U(range->type, ==, DATA);
	ASSERT3U(range->start_blkid + 1, ==, range->end_blkid);
	/*
	* If we have large blocks stored on disk but
	* the send flags don't allow us to send large
	* blocks, we split the data from the arc buf
	* into chunks.
	*/
	boolean_t split_large_blocks =
	srdp->datablksz > SPA_OLD_MAXBLOCKSIZE &&
	!(srta->featureflags & DMU_BACKUP_FEATURE_LARGE_BLOCKS);
	/*
	* We should only request compressed data from the ARC if all
	* the following are true:
	* - stream compression was requested
	* - we aren't splitting large blocks into smaller chunks
	* - the data won't need to be byteswapped before sending
	* - this isn't an embedded block
	* - this isn't metadata (if receiving on a different endian
	* system it can be byteswapped more easily)
	*/
	boolean_t request_compressed =
	(srta->featureflags & DMU_BACKUP_FEATURE_COMPRESSED) &&
	!split_large_blocks && !BP_SHOULD_BYTESWAP(bp) &&
	!BP_IS_EMBEDDED(bp) && !DMU_OT_IS_METADATA(BP_GET_TYPE(bp));

	enum zio_flag zioflags = ZIO_FLAG_CANFAIL;

	- if (srta->featureflags & DMU_BACKUP_FEATURE_RAW)
	+ if (srta->featureflags & DMU_BACKUP_FEATURE_RAW) {
	zioflags \|= ZIO_FLAG_RAW;
	- else if (request_compressed)
	+ srdp->io_compressed = B_TRUE;
	+ } else if (request_compressed) {
	zioflags \|= ZIO_FLAG_RAW_COMPRESS;
	+ srdp->io_compressed = B_TRUE;
	+ }

	srdp->datasz = (zioflags & ZIO_FLAG_RAW_COMPRESS) ?
	BP_GET_PSIZE(bp) : BP_GET_LSIZE(bp);

	if (!srta->issue_reads)
	return;
	if (BP_IS_REDACTED(bp))
	return;
	if (send_do_embed(bp, srta->featureflags))
	return;

	zbookmark_phys_t zb = {
	.zb_objset = dmu_objset_id(os),
	.zb_object = range->object,
	.zb_level = 0,
	.zb_blkid = range->start_blkid,
	};

	arc_flags_t aflags = ARC_FLAG_CACHED_ONLY;

	int arc_err = arc_read(NULL, os->os_spa, bp,
	arc_getbuf_func, &srdp->abuf, ZIO_PRIORITY_ASYNC_READ,
	zioflags, &aflags, &zb);
	/*
	* If the data is not already cached in the ARC, we read directly
	* from zio. This avoids the performance overhead of adding a new
	* entry to the ARC, and we also avoid polluting the ARC cache with
	* data that is not likely to be used in the future.
	*/
	if (arc_err != 0) {
	srdp->abd = abd_alloc_linear(srdp->datasz, B_FALSE);
	srdp->io_outstanding = B_TRUE;
	zio_nowait(zio_read(NULL, os->os_spa, bp, srdp->abd,
	srdp->datasz, dmu_send_read_done, range,
	ZIO_PRIORITY_ASYNC_READ, zioflags, &zb));
	}
	}

	/*
	* Create a new record with the given values.
	*/
	static void
	enqueue_range(struct send_reader_thread_arg srta, bqueue_t q, dnode_t *dn,
	uint64_t blkid, uint64_t count, const blkptr_t *bp, uint32_t datablksz)
	{
	enum type range_type = (bp == NULL \|\| BP_IS_HOLE(bp) ? HOLE :
	(BP_IS_REDACTED(bp) ? REDACT : DATA));

	struct send_range *range = range_alloc(range_type, dn->dn_object,
	blkid, blkid + count, B_FALSE);

	if (blkid == DMU_SPILL_BLKID)
	ASSERT3U(BP_GET_TYPE(bp), ==, DMU_OT_SA);

	switch (range_type) {
	case HOLE:
	range->sru.hole.datablksz = datablksz;
	break;
	case DATA:
	ASSERT3U(count, ==, 1);
	range->sru.data.datablksz = datablksz;
	range->sru.data.obj_type = dn->dn_type;
	range->sru.data.bp = *bp;
	issue_data_read(srta, range);
	break;
	case REDACT:
	range->sru.redact.datablksz = datablksz;
	break;
	default:
	break;
	}
	bqueue_enqueue(q, range, datablksz);
	}

	/*
	* This thread is responsible for two things: First, it retrieves the correct
	* blkptr in the to ds if we need to send the data because of something from
	* the from thread. As a result of this, we're the first ones to discover that
	* some indirect blocks can be discarded because they're not holes. Second,
	* it issues prefetches for the data we need to send.
	*/
	static void
	send_reader_thread(void *arg)
	{
	struct send_reader_thread_arg *srta = arg;
	struct send_merge_thread_arg *smta = srta->smta;
	bqueue_t *inq = &smta->q;
	bqueue_t *outq = &srta->q;
	objset_t *os = smta->os;
	fstrans_cookie_t cookie = spl_fstrans_mark();
	struct send_range *range = bqueue_dequeue(inq);
	int err = 0;

	/*
	* If the record we're analyzing is from a redaction bookmark from the
	* fromds, then we need to know whether or not it exists in the tods so
	* we know whether to create records for it or not. If it does, we need
	* the datablksz so we can generate an appropriate record for it.
	* Finally, if it isn't redacted, we need the blkptr so that we can send
	* a WRITE record containing the actual data.
	*/
	uint64_t last_obj = UINT64_MAX;
	uint64_t last_obj_exists = B_TRUE;
	while (!range->eos_marker && !srta->cancel && smta->error == 0 &&
	err == 0) {
	switch (range->type) {
	case DATA:
	issue_data_read(srta, range);
	bqueue_enqueue(outq, range, range->sru.data.datablksz);
	range = get_next_range_nofree(inq, range);
	break;
	case HOLE:
	case OBJECT:
	case OBJECT_RANGE:
	case REDACT: // Redacted blocks must exist
	bqueue_enqueue(outq, range, sizeof (*range));
	range = get_next_range_nofree(inq, range);
	break;
	case PREVIOUSLY_REDACTED: {
	/*
	* This entry came from the "from bookmark" when
	* sending from a bookmark that has a redaction
	* list. We need to check if this object/blkid
	* exists in the target ("to") dataset, and if
	* not then we drop this entry. We also need
	* to fill in the block pointer so that we know
	* what to prefetch.
	*
	* To accomplish the above, we first cache whether or
	* not the last object we examined exists. If it
	* doesn't, we can drop this record. If it does, we hold
	* the dnode and use it to call dbuf_dnode_findbp. We do
	* this instead of dbuf_bookmark_findbp because we will
	* often operate on large ranges, and holding the dnode
	* once is more efficient.
	*/
	boolean_t object_exists = B_TRUE;
	/*
	* If the data is redacted, we only care if it exists,
	* so that we don't send records for objects that have
	* been deleted.
	*/
	dnode_t *dn;
	if (range->object == last_obj && !last_obj_exists) {
	/*
	* If we're still examining the same object as
	* previously, and it doesn't exist, we don't
	* need to call dbuf_bookmark_findbp.
	*/
	object_exists = B_FALSE;
	} else {
	err = dnode_hold(os, range->object, FTAG, &dn);
	if (err == ENOENT) {
	object_exists = B_FALSE;
	err = 0;
	}
	last_obj = range->object;
	last_obj_exists = object_exists;
	}

	if (err != 0) {
	break;
	} else if (!object_exists) {
	/*
	* The block was modified, but doesn't
	* exist in the to dataset; if it was
	* deleted in the to dataset, then we'll
	* visit the hole bp for it at some point.
	*/
	range = get_next_range(inq, range);
	continue;
	}
	uint64_t file_max =
	(dn->dn_maxblkid < range->end_blkid ?
	dn->dn_maxblkid : range->end_blkid);
	/*
	* The object exists, so we need to try to find the
	* blkptr for each block in the range we're processing.
	*/
	rw_enter(&dn->dn_struct_rwlock, RW_READER);
	for (uint64_t blkid = range->start_blkid;
	blkid < file_max; blkid++) {
	blkptr_t bp;
	uint32_t datablksz =
	dn->dn_phys->dn_datablkszsec <<
	SPA_MINBLOCKSHIFT;
	uint64_t offset = blkid * datablksz;
	/*
	* This call finds the next non-hole block in
	* the object. This is to prevent a
	* performance problem where we're unredacting
	* a large hole. Using dnode_next_offset to
	* skip over the large hole avoids iterating
	* over every block in it.
	*/
	err = dnode_next_offset(dn, DNODE_FIND_HAVELOCK,
	&offset, 1, 1, 0);
	if (err == ESRCH) {
	offset = UINT64_MAX;
	err = 0;
	} else if (err != 0) {
	break;
	}
	if (offset != blkid * datablksz) {
	/*
	* if there is a hole from here
	* (blkid) to offset
	*/
	offset = MIN(offset, file_max *
	datablksz);
	uint64_t nblks = (offset / datablksz) -
	blkid;
	enqueue_range(srta, outq, dn, blkid,
	nblks, NULL, datablksz);
	blkid += nblks;
	}
	if (blkid >= file_max)
	break;
	err = dbuf_dnode_findbp(dn, 0, blkid, &bp,
	NULL, NULL);
	if (err != 0)
	break;
	ASSERT(!BP_IS_HOLE(&bp));
	enqueue_range(srta, outq, dn, blkid, 1, &bp,
	datablksz);
	}
	rw_exit(&dn->dn_struct_rwlock);
	dnode_rele(dn, FTAG);
	range = get_next_range(inq, range);
	}
	}
	}
	if (srta->cancel \|\| err != 0) {
	smta->cancel = B_TRUE;
	srta->error = err;
	} else if (smta->error != 0) {
	srta->error = smta->error;
	}
	while (!range->eos_marker)
	range = get_next_range(inq, range);

	bqueue_enqueue_flush(outq, range, 1);
	spl_fstrans_unmark(cookie);
	thread_exit();
	}

	#define NUM_SNAPS_NOT_REDACTED UINT64_MAX

	struct dmu_send_params {
	/* Pool args */
	void *tag; // Tag that dp was held with, will be used to release dp.
	dsl_pool_t *dp;
	/* To snapshot args */
	const char *tosnap;
	dsl_dataset_t *to_ds;
	/* From snapshot args */
	zfs_bookmark_phys_t ancestor_zb;
	uint64_t *fromredactsnaps;
	/* NUM_SNAPS_NOT_REDACTED if not sending from redaction bookmark */
	uint64_t numfromredactsnaps;
	/* Stream params */
	boolean_t is_clone;
	boolean_t embedok;
	boolean_t large_block_ok;
	boolean_t compressok;
	boolean_t rawok;
	boolean_t savedok;
	uint64_t resumeobj;
	uint64_t resumeoff;
	uint64_t saved_guid;
	zfs_bookmark_phys_t *redactbook;
	/* Stream output params */
	dmu_send_outparams_t *dso;

	/* Stream progress params */
	offset_t *off;
	int outfd;
	char saved_toname[MAXNAMELEN];
	};

	static int
	setup_featureflags(struct dmu_send_params dspp, objset_t os,
	uint64_t *featureflags)
	{
	dsl_dataset_t *to_ds = dspp->to_ds;
	dsl_pool_t *dp = dspp->dp;
	#ifdef _KERNEL
	if (dmu_objset_type(os) == DMU_OST_ZFS) {
	uint64_t version;
	if (zfs_get_zplprop(os, ZFS_PROP_VERSION, &version) != 0)
	return (SET_ERROR(EINVAL));

	if (version >= ZPL_VERSION_SA)
	*featureflags \|= DMU_BACKUP_FEATURE_SA_SPILL;
	}
	#endif

	/* raw sends imply large_block_ok */
	if ((dspp->rawok \|\| dspp->large_block_ok) &&
	dsl_dataset_feature_is_active(to_ds, SPA_FEATURE_LARGE_BLOCKS)) {
	*featureflags \|= DMU_BACKUP_FEATURE_LARGE_BLOCKS;
	}

	/* encrypted datasets will not have embedded blocks */
	if ((dspp->embedok \|\| dspp->rawok) && !os->os_encrypted &&
	spa_feature_is_active(dp->dp_spa, SPA_FEATURE_EMBEDDED_DATA)) {
	*featureflags \|= DMU_BACKUP_FEATURE_EMBED_DATA;
	}

	/* raw send implies compressok */
	if (dspp->compressok \|\| dspp->rawok)
	*featureflags \|= DMU_BACKUP_FEATURE_COMPRESSED;

	if (dspp->rawok && os->os_encrypted)
	*featureflags \|= DMU_BACKUP_FEATURE_RAW;

	if ((*featureflags &
	(DMU_BACKUP_FEATURE_EMBED_DATA \| DMU_BACKUP_FEATURE_COMPRESSED \|
	DMU_BACKUP_FEATURE_RAW)) != 0 &&
	spa_feature_is_active(dp->dp_spa, SPA_FEATURE_LZ4_COMPRESS)) {
	*featureflags \|= DMU_BACKUP_FEATURE_LZ4;
	}

	/*
	* We specifically do not include DMU_BACKUP_FEATURE_EMBED_DATA here to
	* allow sending ZSTD compressed datasets to a receiver that does not
	* support ZSTD
	*/
	if ((*featureflags &
	(DMU_BACKUP_FEATURE_COMPRESSED \| DMU_BACKUP_FEATURE_RAW)) != 0 &&
	dsl_dataset_feature_is_active(to_ds, SPA_FEATURE_ZSTD_COMPRESS)) {
	*featureflags \|= DMU_BACKUP_FEATURE_ZSTD;
	}

	if (dspp->resumeobj != 0 \|\| dspp->resumeoff != 0) {
	*featureflags \|= DMU_BACKUP_FEATURE_RESUMING;
	}

	if (dspp->redactbook != NULL) {
	*featureflags \|= DMU_BACKUP_FEATURE_REDACTED;
	}

	if (dsl_dataset_feature_is_active(to_ds, SPA_FEATURE_LARGE_DNODE)) {
	*featureflags \|= DMU_BACKUP_FEATURE_LARGE_DNODE;
	}
	return (0);
	}

	static dmu_replay_record_t *
	create_begin_record(struct dmu_send_params dspp, objset_t os,
	uint64_t featureflags)
	{
	dmu_replay_record_t *drr = kmem_zalloc(sizeof (dmu_replay_record_t),
	KM_SLEEP);
	drr->drr_type = DRR_BEGIN;

	struct drr_begin *drrb = &drr->drr_u.drr_begin;
	dsl_dataset_t *to_ds = dspp->to_ds;

	drrb->drr_magic = DMU_BACKUP_MAGIC;
	drrb->drr_creation_time = dsl_dataset_phys(to_ds)->ds_creation_time;
	drrb->drr_type = dmu_objset_type(os);
	drrb->drr_toguid = dsl_dataset_phys(to_ds)->ds_guid;
	drrb->drr_fromguid = dspp->ancestor_zb.zbm_guid;

	DMU_SET_STREAM_HDRTYPE(drrb->drr_versioninfo, DMU_SUBSTREAM);
	DMU_SET_FEATUREFLAGS(drrb->drr_versioninfo, featureflags);

	if (dspp->is_clone)
	drrb->drr_flags \|= DRR_FLAG_CLONE;
	if (dsl_dataset_phys(dspp->to_ds)->ds_flags & DS_FLAG_CI_DATASET)
	drrb->drr_flags \|= DRR_FLAG_CI_DATA;
	if (zfs_send_set_freerecords_bit)
	drrb->drr_flags \|= DRR_FLAG_FREERECORDS;
	drr->drr_u.drr_begin.drr_flags \|= DRR_FLAG_SPILL_BLOCK;

	if (dspp->savedok) {
	drrb->drr_toguid = dspp->saved_guid;
	strlcpy(drrb->drr_toname, dspp->saved_toname,
	sizeof (drrb->drr_toname));
	} else {
	dsl_dataset_name(to_ds, drrb->drr_toname);
	if (!to_ds->ds_is_snapshot) {
	(void) strlcat(drrb->drr_toname, "@--head--",
	sizeof (drrb->drr_toname));
	}
	}
	return (drr);
	}

	static void
	setup_to_thread(struct send_thread_arg to_arg, objset_t to_os,
	dmu_sendstatus_t *dssp, uint64_t fromtxg, boolean_t rawok)
	{
	VERIFY0(bqueue_init(&to_arg->q, zfs_send_no_prefetch_queue_ff,
	MAX(zfs_send_no_prefetch_queue_length, 2 * zfs_max_recordsize),
	offsetof(struct send_range, ln)));
	to_arg->error_code = 0;
	to_arg->cancel = B_FALSE;
	to_arg->os = to_os;
	to_arg->fromtxg = fromtxg;
	to_arg->flags = TRAVERSE_PRE \| TRAVERSE_PREFETCH_METADATA;
	if (rawok)
	to_arg->flags \|= TRAVERSE_NO_DECRYPT;
	if (zfs_send_corrupt_data)
	to_arg->flags \|= TRAVERSE_HARD;
	to_arg->num_blocks_visited = &dssp->dss_blocks;
	(void) thread_create(NULL, 0, send_traverse_thread, to_arg, 0,
	curproc, TS_RUN, minclsyspri);
	}

	static void
	setup_from_thread(struct redact_list_thread_arg *from_arg,
	redaction_list_t from_rl, dmu_sendstatus_t dssp)
	{
	VERIFY0(bqueue_init(&from_arg->q, zfs_send_no_prefetch_queue_ff,
	MAX(zfs_send_no_prefetch_queue_length, 2 * zfs_max_recordsize),
	offsetof(struct send_range, ln)));
	from_arg->error_code = 0;
	from_arg->cancel = B_FALSE;
	from_arg->rl = from_rl;
	from_arg->mark_redact = B_FALSE;
	from_arg->num_blocks_visited = &dssp->dss_blocks;
	/*
	* If from_ds is null, send_traverse_thread just returns success and
	* enqueues an eos marker.
	*/
	(void) thread_create(NULL, 0, redact_list_thread, from_arg, 0,
	curproc, TS_RUN, minclsyspri);
	}

	static void
	setup_redact_list_thread(struct redact_list_thread_arg *rlt_arg,
	struct dmu_send_params dspp, redaction_list_t rl, dmu_sendstatus_t *dssp)
	{
	if (dspp->redactbook == NULL)
	return;

	rlt_arg->cancel = B_FALSE;
	VERIFY0(bqueue_init(&rlt_arg->q, zfs_send_no_prefetch_queue_ff,
	MAX(zfs_send_no_prefetch_queue_length, 2 * zfs_max_recordsize),
	offsetof(struct send_range, ln)));
	rlt_arg->error_code = 0;
	rlt_arg->mark_redact = B_TRUE;
	rlt_arg->rl = rl;
	rlt_arg->num_blocks_visited = &dssp->dss_blocks;

	(void) thread_create(NULL, 0, redact_list_thread, rlt_arg, 0,
	curproc, TS_RUN, minclsyspri);
	}

	static void
	setup_merge_thread(struct send_merge_thread_arg *smt_arg,
	struct dmu_send_params dspp, struct redact_list_thread_arg from_arg,
	struct send_thread_arg to_arg, struct redact_list_thread_arg rlt_arg,
	objset_t *os)
	{
	VERIFY0(bqueue_init(&smt_arg->q, zfs_send_no_prefetch_queue_ff,
	MAX(zfs_send_no_prefetch_queue_length, 2 * zfs_max_recordsize),
	offsetof(struct send_range, ln)));
	smt_arg->cancel = B_FALSE;
	smt_arg->error = 0;
	smt_arg->from_arg = from_arg;
	smt_arg->to_arg = to_arg;
	if (dspp->redactbook != NULL)
	smt_arg->redact_arg = rlt_arg;

	smt_arg->os = os;
	(void) thread_create(NULL, 0, send_merge_thread, smt_arg, 0, curproc,
	TS_RUN, minclsyspri);
	}

	static void
	setup_reader_thread(struct send_reader_thread_arg *srt_arg,
	struct dmu_send_params dspp, struct send_merge_thread_arg smt_arg,
	uint64_t featureflags)
	{
	VERIFY0(bqueue_init(&srt_arg->q, zfs_send_queue_ff,
	MAX(zfs_send_queue_length, 2 * zfs_max_recordsize),
	offsetof(struct send_range, ln)));
	srt_arg->smta = smt_arg;
	srt_arg->issue_reads = !dspp->dso->dso_dryrun;
	srt_arg->featureflags = featureflags;
	(void) thread_create(NULL, 0, send_reader_thread, srt_arg, 0,
	curproc, TS_RUN, minclsyspri);
	}

	static int
	setup_resume_points(struct dmu_send_params *dspp,
	struct send_thread_arg to_arg, struct redact_list_thread_arg from_arg,
	struct redact_list_thread_arg *rlt_arg,
	struct send_merge_thread_arg smt_arg, boolean_t resuming, objset_t os,
	redaction_list_t redact_rl, nvlist_t nvl)
	{
	dsl_dataset_t *to_ds = dspp->to_ds;
	int err = 0;

	uint64_t obj = 0;
	uint64_t blkid = 0;
	if (resuming) {
	obj = dspp->resumeobj;
	dmu_object_info_t to_doi;
	err = dmu_object_info(os, obj, &to_doi);
	if (err != 0)
	return (err);

	blkid = dspp->resumeoff / to_doi.doi_data_block_size;
	}
	/*
	* If we're resuming a redacted send, we can skip to the appropriate
	* point in the redaction bookmark by binary searching through it.
	*/
	if (redact_rl != NULL) {
	SET_BOOKMARK(&rlt_arg->resume, to_ds->ds_object, obj, 0, blkid);
	}

	SET_BOOKMARK(&to_arg->resume, to_ds->ds_object, obj, 0, blkid);
	if (nvlist_exists(nvl, BEGINNV_REDACT_FROM_SNAPS)) {
	uint64_t objset = dspp->ancestor_zb.zbm_redaction_obj;
	/*
	* Note: If the resume point is in an object whose
	* blocksize is different in the from vs to snapshots,
	* we will have divided by the "wrong" blocksize.
	* However, in this case fromsnap's send_cb() will
	* detect that the blocksize has changed and therefore
	* ignore this object.
	*
	* If we're resuming a send from a redaction bookmark,
	* we still cannot accidentally suggest blocks behind
	* the to_ds. In addition, we know that any blocks in
	* the object in the to_ds will have to be sent, since
	* the size changed. Therefore, we can't cause any harm
	* this way either.
	*/
	SET_BOOKMARK(&from_arg->resume, objset, obj, 0, blkid);
	}
	if (resuming) {
	fnvlist_add_uint64(nvl, BEGINNV_RESUME_OBJECT, dspp->resumeobj);
	fnvlist_add_uint64(nvl, BEGINNV_RESUME_OFFSET, dspp->resumeoff);
	}
	return (0);
	}

	static dmu_sendstatus_t *
	setup_send_progress(struct dmu_send_params *dspp)
	{
	dmu_sendstatus_t dssp = kmem_zalloc(sizeof (dssp), KM_SLEEP);
	dssp->dss_outfd = dspp->outfd;
	dssp->dss_off = dspp->off;
	dssp->dss_proc = curproc;
	mutex_enter(&dspp->to_ds->ds_sendstream_lock);
	list_insert_head(&dspp->to_ds->ds_sendstreams, dssp);
	mutex_exit(&dspp->to_ds->ds_sendstream_lock);
	return (dssp);
	}

	/*
	* Actually do the bulk of the work in a zfs send.
	*
	* The idea is that we want to do a send from ancestor_zb to to_ds. We also
	* want to not send any data that has been modified by all the datasets in
	* redactsnaparr, and store the list of blocks that are redacted in this way in
	* a bookmark named redactbook, created on the to_ds. We do this by creating
	* several worker threads, whose function is described below.
	*
	* There are three cases.
	* The first case is a redacted zfs send. In this case there are 5 threads.
	* The first thread is the to_ds traversal thread: it calls dataset_traverse on
	* the to_ds and finds all the blocks that have changed since ancestor_zb (if
	* it's a full send, that's all blocks in the dataset). It then sends those
	* blocks on to the send merge thread. The redact list thread takes the data
	* from the redaction bookmark and sends those blocks on to the send merge
	* thread. The send merge thread takes the data from the to_ds traversal
	* thread, and combines it with the redaction records from the redact list
	* thread. If a block appears in both the to_ds's data and the redaction data,
	* the send merge thread will mark it as redacted and send it on to the prefetch
	* thread. Otherwise, the send merge thread will send the block on to the
	* prefetch thread unchanged. The prefetch thread will issue prefetch reads for
	* any data that isn't redacted, and then send the data on to the main thread.
	* The main thread behaves the same as in a normal send case, issuing demand
	* reads for data blocks and sending out records over the network
	*
	* The graphic below diagrams the flow of data in the case of a redacted zfs
	* send. Each box represents a thread, and each line represents the flow of
	* data.
	*
	* Records from the \|
	* redaction bookmark \|
	* +--------------------+ \| +---------------------------+
	* \| \| v \| Send Merge Thread \|
	* \| Redact List Thread +----------> Apply redaction marks to \|
	* \| \| \| records as specified by \|
	* +--------------------+ \| redaction ranges \|
	* +----^---------------+------+
	* \| \| Merged data
	* \| \|
	* \| +------------v--------+
	* \| \| Prefetch Thread \|
	* +--------------------+ \| \| Issues prefetch \|
	* \| to_ds Traversal \| \| \| reads of data blocks\|
	* \| Thread (finds +---------------+ +------------+--------+
	* \| candidate blocks) \| Blocks modified \| Prefetched data
	* +--------------------+ by to_ds since \|
	* ancestor_zb +------------v----+
	* \| Main Thread \| File Descriptor
	* \| Sends data over +->(to zfs receive)
	* \| wire \|
	* +-----------------+
	*
	* The second case is an incremental send from a redaction bookmark. The to_ds
	* traversal thread and the main thread behave the same as in the redacted
	* send case. The new thread is the from bookmark traversal thread. It
	* iterates over the redaction list in the redaction bookmark, and enqueues
	* records for each block that was redacted in the original send. The send
	* merge thread now has to merge the data from the two threads. For details
	* about that process, see the header comment of send_merge_thread(). Any data
	* it decides to send on will be prefetched by the prefetch thread. Note that
	* you can perform a redacted send from a redaction bookmark; in that case,
	* the data flow behaves very similarly to the flow in the redacted send case,
	* except with the addition of the bookmark traversal thread iterating over the
	* redaction bookmark. The send_merge_thread also has to take on the
	* responsibility of merging the redact list thread's records, the bookmark
	* traversal thread's records, and the to_ds records.
	*
	* +---------------------+
	* \| \|
	* \| Redact List Thread +--------------+
	* \| \| \|
	* +---------------------+ \|
	* Blocks in redaction list \| Ranges modified by every secure snap
	* of from bookmark \| (or EOS if not readcted)
	* \|
	* +---------------------+ \| +----v----------------------+
	* \| bookmark Traversal \| v \| Send Merge Thread \|
	* \| Thread (finds +---------> Merges bookmark, rlt, and \|
	* \| candidate blocks) \| \| to_ds send records \|
	* +---------------------+ +----^---------------+------+
	* \| \| Merged data
	* \| +------------v--------+
	* \| \| Prefetch Thread \|
	* +--------------------+ \| \| Issues prefetch \|
	* \| to_ds Traversal \| \| \| reads of data blocks\|
	* \| Thread (finds +---------------+ +------------+--------+
	* \| candidate blocks) \| Blocks modified \| Prefetched data
	* +--------------------+ by to_ds since +------------v----+
	* ancestor_zb \| Main Thread \| File Descriptor
	* \| Sends data over +->(to zfs receive)
	* \| wire \|
	* +-----------------+
	*
	* The final case is a simple zfs full or incremental send. The to_ds traversal
	* thread behaves the same as always. The redact list thread is never started.
	* The send merge thread takes all the blocks that the to_ds traversal thread
	* sends it, prefetches the data, and sends the blocks on to the main thread.
	* The main thread sends the data over the wire.
	*
	* To keep performance acceptable, we want to prefetch the data in the worker
	* threads. While the to_ds thread could simply use the TRAVERSE_PREFETCH
	* feature built into traverse_dataset, the combining and deletion of records
	* due to redaction and sends from redaction bookmarks mean that we could
	* issue many unnecessary prefetches. As a result, we only prefetch data
	* after we've determined that the record is not going to be redacted. To
	* prevent the prefetching from getting too far ahead of the main thread, the
	* blocking queues that are used for communication are capped not by the
	* number of entries in the queue, but by the sum of the size of the
	* prefetches associated with them. The limit on the amount of data that the
	* thread can prefetch beyond what the main thread has reached is controlled
	* by the global variable zfs_send_queue_length. In addition, to prevent poor
	* performance in the beginning of a send, we also limit the distance ahead
	* that the traversal threads can be. That distance is controlled by the
	* zfs_send_no_prefetch_queue_length tunable.
	*
	* Note: Releases dp using the specified tag.
	*/
	static int
	dmu_send_impl(struct dmu_send_params *dspp)
	{
	objset_t *os;
	dmu_replay_record_t *drr;
	dmu_sendstatus_t *dssp;
	dmu_send_cookie_t dsc = {0};
	int err;
	uint64_t fromtxg = dspp->ancestor_zb.zbm_creation_txg;
	uint64_t featureflags = 0;
	struct redact_list_thread_arg *from_arg;
	struct send_thread_arg *to_arg;
	struct redact_list_thread_arg *rlt_arg;
	struct send_merge_thread_arg *smt_arg;
	struct send_reader_thread_arg *srt_arg;
	struct send_range *range;
	redaction_list_t *from_rl = NULL;
	redaction_list_t *redact_rl = NULL;
	boolean_t resuming = (dspp->resumeobj != 0 \|\| dspp->resumeoff != 0);
	boolean_t book_resuming = resuming;

	dsl_dataset_t *to_ds = dspp->to_ds;
	zfs_bookmark_phys_t *ancestor_zb = &dspp->ancestor_zb;
	dsl_pool_t *dp = dspp->dp;
	void *tag = dspp->tag;

	err = dmu_objset_from_ds(to_ds, &os);
	if (err != 0) {
	dsl_pool_rele(dp, tag);
	return (err);
	}

	/*
	* If this is a non-raw send of an encrypted ds, we can ensure that
	* the objset_phys_t is authenticated. This is safe because this is
	* either a snapshot or we have owned the dataset, ensuring that
	* it can't be modified.
	*/
	if (!dspp->rawok && os->os_encrypted &&
	arc_is_unauthenticated(os->os_phys_buf)) {
	zbookmark_phys_t zb;

	SET_BOOKMARK(&zb, to_ds->ds_object, ZB_ROOT_OBJECT,
	ZB_ROOT_LEVEL, ZB_ROOT_BLKID);
	err = arc_untransform(os->os_phys_buf, os->os_spa,
	&zb, B_FALSE);
	if (err != 0) {
	dsl_pool_rele(dp, tag);
	return (err);
	}

	ASSERT0(arc_is_unauthenticated(os->os_phys_buf));
	}

	if ((err = setup_featureflags(dspp, os, &featureflags)) != 0) {
	dsl_pool_rele(dp, tag);
	return (err);
	}

	/*
	* If we're doing a redacted send, hold the bookmark's redaction list.
	*/
	if (dspp->redactbook != NULL) {
	err = dsl_redaction_list_hold_obj(dp,
	dspp->redactbook->zbm_redaction_obj, FTAG,
	&redact_rl);
	if (err != 0) {
	dsl_pool_rele(dp, tag);
	return (SET_ERROR(EINVAL));
	}
	dsl_redaction_list_long_hold(dp, redact_rl, FTAG);
	}

	/*
	* If we're sending from a redaction bookmark, hold the redaction list
	* so that we can consider sending the redacted blocks.
	*/
	if (ancestor_zb->zbm_redaction_obj != 0) {
	err = dsl_redaction_list_hold_obj(dp,
	ancestor_zb->zbm_redaction_obj, FTAG, &from_rl);
	if (err != 0) {
	if (redact_rl != NULL) {
	dsl_redaction_list_long_rele(redact_rl, FTAG);
	dsl_redaction_list_rele(redact_rl, FTAG);
	}
	dsl_pool_rele(dp, tag);
	return (SET_ERROR(EINVAL));
	}
	dsl_redaction_list_long_hold(dp, from_rl, FTAG);
	}

	dsl_dataset_long_hold(to_ds, FTAG);

	from_arg = kmem_zalloc(sizeof (*from_arg), KM_SLEEP);
	to_arg = kmem_zalloc(sizeof (*to_arg), KM_SLEEP);
	rlt_arg = kmem_zalloc(sizeof (*rlt_arg), KM_SLEEP);
	smt_arg = kmem_zalloc(sizeof (*smt_arg), KM_SLEEP);
	srt_arg = kmem_zalloc(sizeof (*srt_arg), KM_SLEEP);

	drr = create_begin_record(dspp, os, featureflags);
	dssp = setup_send_progress(dspp);

	dsc.dsc_drr = drr;
	dsc.dsc_dso = dspp->dso;
	dsc.dsc_os = os;
	dsc.dsc_off = dspp->off;
	dsc.dsc_toguid = dsl_dataset_phys(to_ds)->ds_guid;
	dsc.dsc_fromtxg = fromtxg;
	dsc.dsc_pending_op = PENDING_NONE;
	dsc.dsc_featureflags = featureflags;
	dsc.dsc_resume_object = dspp->resumeobj;
	dsc.dsc_resume_offset = dspp->resumeoff;

	dsl_pool_rele(dp, tag);

	void *payload = NULL;
	size_t payload_len = 0;
	nvlist_t *nvl = fnvlist_alloc();

	/*
	* If we're doing a redacted send, we include the snapshots we're
	* redacted with respect to so that the target system knows what send
	* streams can be correctly received on top of this dataset. If we're
	* instead sending a redacted dataset, we include the snapshots that the
	* dataset was created with respect to.
	*/
	if (dspp->redactbook != NULL) {
	fnvlist_add_uint64_array(nvl, BEGINNV_REDACT_SNAPS,
	redact_rl->rl_phys->rlp_snaps,
	redact_rl->rl_phys->rlp_num_snaps);
	} else if (dsl_dataset_feature_is_active(to_ds,
	SPA_FEATURE_REDACTED_DATASETS)) {
	uint64_t *tods_guids;
	uint64_t length;
	VERIFY(dsl_dataset_get_uint64_array_feature(to_ds,
	SPA_FEATURE_REDACTED_DATASETS, &length, &tods_guids));
	fnvlist_add_uint64_array(nvl, BEGINNV_REDACT_SNAPS, tods_guids,
	length);
	}

	/*
	* If we're sending from a redaction bookmark, then we should retrieve
	* the guids of that bookmark so we can send them over the wire.
	*/
	if (from_rl != NULL) {
	fnvlist_add_uint64_array(nvl, BEGINNV_REDACT_FROM_SNAPS,
	from_rl->rl_phys->rlp_snaps,
	from_rl->rl_phys->rlp_num_snaps);
	}

	/*
	* If the snapshot we're sending from is redacted, include the redaction
	* list in the stream.
	*/
	if (dspp->numfromredactsnaps != NUM_SNAPS_NOT_REDACTED) {
	ASSERT3P(from_rl, ==, NULL);
	fnvlist_add_uint64_array(nvl, BEGINNV_REDACT_FROM_SNAPS,
	dspp->fromredactsnaps, (uint_t)dspp->numfromredactsnaps);
	if (dspp->numfromredactsnaps > 0) {
	kmem_free(dspp->fromredactsnaps,
	dspp->numfromredactsnaps * sizeof (uint64_t));
	dspp->fromredactsnaps = NULL;
	}
	}

	if (resuming \|\| book_resuming) {
	err = setup_resume_points(dspp, to_arg, from_arg,
	rlt_arg, smt_arg, resuming, os, redact_rl, nvl);
	if (err != 0)
	goto out;
	}

	if (featureflags & DMU_BACKUP_FEATURE_RAW) {
	uint64_t ivset_guid = (ancestor_zb != NULL) ?
	ancestor_zb->zbm_ivset_guid : 0;
	nvlist_t *keynvl = NULL;
	ASSERT(os->os_encrypted);

	err = dsl_crypto_populate_key_nvlist(os, ivset_guid,
	&keynvl);
	if (err != 0) {
	fnvlist_free(nvl);
	goto out;
	}

	fnvlist_add_nvlist(nvl, "crypt_keydata", keynvl);
	fnvlist_free(keynvl);
	}

	if (!nvlist_empty(nvl)) {
	payload = fnvlist_pack(nvl, &payload_len);
	drr->drr_payloadlen = payload_len;
	}

	fnvlist_free(nvl);
	err = dump_record(&dsc, payload, payload_len);
	fnvlist_pack_free(payload, payload_len);
	if (err != 0) {
	err = dsc.dsc_err;
	goto out;
	}

	setup_to_thread(to_arg, os, dssp, fromtxg, dspp->rawok);
	setup_from_thread(from_arg, from_rl, dssp);
	setup_redact_list_thread(rlt_arg, dspp, redact_rl, dssp);
	setup_merge_thread(smt_arg, dspp, from_arg, to_arg, rlt_arg, os);
	setup_reader_thread(srt_arg, dspp, smt_arg, featureflags);

	range = bqueue_dequeue(&srt_arg->q);
	while (err == 0 && !range->eos_marker) {
	err = do_dump(&dsc, range);
	range = get_next_range(&srt_arg->q, range);
	if (issig(JUSTLOOKING) && issig(FORREAL))
	err = SET_ERROR(EINTR);
	}

	/*
	* If we hit an error or are interrupted, cancel our worker threads and
	* clear the queue of any pending records. The threads will pass the
	* cancel up the tree of worker threads, and each one will clean up any
	* pending records before exiting.
	*/
	if (err != 0) {
	srt_arg->cancel = B_TRUE;
	while (!range->eos_marker) {
	range = get_next_range(&srt_arg->q, range);
	}
	}
	range_free(range);

	bqueue_destroy(&srt_arg->q);
	bqueue_destroy(&smt_arg->q);
	if (dspp->redactbook != NULL)
	bqueue_destroy(&rlt_arg->q);
	bqueue_destroy(&to_arg->q);
	bqueue_destroy(&from_arg->q);

	if (err == 0 && srt_arg->error != 0)
	err = srt_arg->error;

	if (err != 0)
	goto out;

	if (dsc.dsc_pending_op != PENDING_NONE)
	if (dump_record(&dsc, NULL, 0) != 0)
	err = SET_ERROR(EINTR);

	if (err != 0) {
	if (err == EINTR && dsc.dsc_err != 0)
	err = dsc.dsc_err;
	goto out;
	}

	/*
	* Send the DRR_END record if this is not a saved stream.
	* Otherwise, the omitted DRR_END record will signal to
	* the receive side that the stream is incomplete.
	*/
	if (!dspp->savedok) {
	bzero(drr, sizeof (dmu_replay_record_t));
	drr->drr_type = DRR_END;
	drr->drr_u.drr_end.drr_checksum = dsc.dsc_zc;
	drr->drr_u.drr_end.drr_toguid = dsc.dsc_toguid;

	if (dump_record(&dsc, NULL, 0) != 0)
	err = dsc.dsc_err;
	}
	out:
	mutex_enter(&to_ds->ds_sendstream_lock);
	list_remove(&to_ds->ds_sendstreams, dssp);
	mutex_exit(&to_ds->ds_sendstream_lock);

	VERIFY(err != 0 \|\| (dsc.dsc_sent_begin &&
	(dsc.dsc_sent_end \|\| dspp->savedok)));

	kmem_free(drr, sizeof (dmu_replay_record_t));
	kmem_free(dssp, sizeof (dmu_sendstatus_t));
	kmem_free(from_arg, sizeof (*from_arg));
	kmem_free(to_arg, sizeof (*to_arg));
	kmem_free(rlt_arg, sizeof (*rlt_arg));
	kmem_free(smt_arg, sizeof (*smt_arg));
	kmem_free(srt_arg, sizeof (*srt_arg));

	dsl_dataset_long_rele(to_ds, FTAG);
	if (from_rl != NULL) {
	dsl_redaction_list_long_rele(from_rl, FTAG);
	dsl_redaction_list_rele(from_rl, FTAG);
	}
	if (redact_rl != NULL) {
	dsl_redaction_list_long_rele(redact_rl, FTAG);
	dsl_redaction_list_rele(redact_rl, FTAG);
	}

	return (err);
	}

	int
	dmu_send_obj(const char *pool, uint64_t tosnap, uint64_t fromsnap,
	boolean_t embedok, boolean_t large_block_ok, boolean_t compressok,
	boolean_t rawok, boolean_t savedok, int outfd, offset_t *off,
	dmu_send_outparams_t *dsop)
	{
	int err;
	dsl_dataset_t *fromds;
	ds_hold_flags_t dsflags;
	struct dmu_send_params dspp = {0};
	dspp.embedok = embedok;
	dspp.large_block_ok = large_block_ok;
	dspp.compressok = compressok;
	dspp.outfd = outfd;
	dspp.off = off;
	dspp.dso = dsop;
	dspp.tag = FTAG;
	dspp.rawok = rawok;
	dspp.savedok = savedok;

	dsflags = (rawok) ? DS_HOLD_FLAG_NONE : DS_HOLD_FLAG_DECRYPT;
	err = dsl_pool_hold(pool, FTAG, &dspp.dp);
	if (err != 0)
	return (err);

	err = dsl_dataset_hold_obj_flags(dspp.dp, tosnap, dsflags, FTAG,
	&dspp.to_ds);
	if (err != 0) {
	dsl_pool_rele(dspp.dp, FTAG);
	return (err);
	}

	if (fromsnap != 0) {
	err = dsl_dataset_hold_obj_flags(dspp.dp, fromsnap, dsflags,
	FTAG, &fromds);
	if (err != 0) {
	dsl_dataset_rele_flags(dspp.to_ds, dsflags, FTAG);
	dsl_pool_rele(dspp.dp, FTAG);
	return (err);
	}
	dspp.ancestor_zb.zbm_guid = dsl_dataset_phys(fromds)->ds_guid;
	dspp.ancestor_zb.zbm_creation_txg =
	dsl_dataset_phys(fromds)->ds_creation_txg;
	dspp.ancestor_zb.zbm_creation_time =
	dsl_dataset_phys(fromds)->ds_creation_time;

	if (dsl_dataset_is_zapified(fromds)) {
	(void) zap_lookup(dspp.dp->dp_meta_objset,
	fromds->ds_object, DS_FIELD_IVSET_GUID, 8, 1,
	&dspp.ancestor_zb.zbm_ivset_guid);
	}

	/* See dmu_send for the reasons behind this. */
	uint64_t *fromredact;

	if (!dsl_dataset_get_uint64_array_feature(fromds,
	SPA_FEATURE_REDACTED_DATASETS,
	&dspp.numfromredactsnaps,
	&fromredact)) {
	dspp.numfromredactsnaps = NUM_SNAPS_NOT_REDACTED;
	} else if (dspp.numfromredactsnaps > 0) {
	uint64_t size = dspp.numfromredactsnaps *
	sizeof (uint64_t);
	dspp.fromredactsnaps = kmem_zalloc(size, KM_SLEEP);
	bcopy(fromredact, dspp.fromredactsnaps, size);
	}

	boolean_t is_before =
	dsl_dataset_is_before(dspp.to_ds, fromds, 0);
	dspp.is_clone = (dspp.to_ds->ds_dir !=
	fromds->ds_dir);
	dsl_dataset_rele(fromds, FTAG);
	if (!is_before) {
	dsl_pool_rele(dspp.dp, FTAG);
	err = SET_ERROR(EXDEV);
	} else {
	err = dmu_send_impl(&dspp);
	}
	} else {
	dspp.numfromredactsnaps = NUM_SNAPS_NOT_REDACTED;
	err = dmu_send_impl(&dspp);
	}
	dsl_dataset_rele(dspp.to_ds, FTAG);
	return (err);
	}

	int
	dmu_send(const char tosnap, const char fromsnap, boolean_t embedok,
	boolean_t large_block_ok, boolean_t compressok, boolean_t rawok,
	boolean_t savedok, uint64_t resumeobj, uint64_t resumeoff,
	const char redactbook, int outfd, offset_t off,
	dmu_send_outparams_t *dsop)
	{
	int err = 0;
	ds_hold_flags_t dsflags;
	boolean_t owned = B_FALSE;
	dsl_dataset_t *fromds = NULL;
	zfs_bookmark_phys_t book = {0};
	struct dmu_send_params dspp = {0};

	dsflags = (rawok) ? DS_HOLD_FLAG_NONE : DS_HOLD_FLAG_DECRYPT;
	dspp.tosnap = tosnap;
	dspp.embedok = embedok;
	dspp.large_block_ok = large_block_ok;
	dspp.compressok = compressok;
	dspp.outfd = outfd;
	dspp.off = off;
	dspp.dso = dsop;
	dspp.tag = FTAG;
	dspp.resumeobj = resumeobj;
	dspp.resumeoff = resumeoff;
	dspp.rawok = rawok;
	dspp.savedok = savedok;

	if (fromsnap != NULL && strpbrk(fromsnap, "@#") == NULL)
	return (SET_ERROR(EINVAL));

	err = dsl_pool_hold(tosnap, FTAG, &dspp.dp);
	if (err != 0)
	return (err);

	if (strchr(tosnap, '@') == NULL && spa_writeable(dspp.dp->dp_spa)) {
	/*
	* We are sending a filesystem or volume. Ensure
	* that it doesn't change by owning the dataset.
	*/

	if (savedok) {
	/*
	* We are looking for the dataset that represents the
	* partially received send stream. If this stream was
	* received as a new snapshot of an existing dataset,
	* this will be saved in a hidden clone named
	* "<pool>/<dataset>/%recv". Otherwise, the stream
	* will be saved in the live dataset itself. In
	* either case we need to use dsl_dataset_own_force()
	* because the stream is marked as inconsistent,
	* which would normally make it unavailable to be
	* owned.
	*/
	char *name = kmem_asprintf("%s/%s", tosnap,
	recv_clone_name);
	err = dsl_dataset_own_force(dspp.dp, name, dsflags,
	FTAG, &dspp.to_ds);
	if (err == ENOENT) {
	err = dsl_dataset_own_force(dspp.dp, tosnap,
	dsflags, FTAG, &dspp.to_ds);
	}

	if (err == 0) {
	err = zap_lookup(dspp.dp->dp_meta_objset,
	dspp.to_ds->ds_object,
	DS_FIELD_RESUME_TOGUID, 8, 1,
	&dspp.saved_guid);
	}

	if (err == 0) {
	err = zap_lookup(dspp.dp->dp_meta_objset,
	dspp.to_ds->ds_object,
	DS_FIELD_RESUME_TONAME, 1,
	sizeof (dspp.saved_toname),
	dspp.saved_toname);
	}
	if (err != 0)
	dsl_dataset_disown(dspp.to_ds, dsflags, FTAG);

	kmem_strfree(name);
	} else {
	err = dsl_dataset_own(dspp.dp, tosnap, dsflags,
	FTAG, &dspp.to_ds);
	}
	owned = B_TRUE;
	} else {
	err = dsl_dataset_hold_flags(dspp.dp, tosnap, dsflags, FTAG,
	&dspp.to_ds);
	}

	if (err != 0) {
	dsl_pool_rele(dspp.dp, FTAG);
	return (err);
	}

	if (redactbook != NULL) {
	char path[ZFS_MAX_DATASET_NAME_LEN];
	(void) strlcpy(path, tosnap, sizeof (path));
	char *at = strchr(path, '@');
	if (at == NULL) {
	err = EINVAL;
	} else {
	(void) snprintf(at, sizeof (path) - (at - path), "#%s",
	redactbook);
	err = dsl_bookmark_lookup(dspp.dp, path,
	NULL, &book);
	dspp.redactbook = &book;
	}
	}

	if (err != 0) {
	dsl_pool_rele(dspp.dp, FTAG);
	if (owned)
	dsl_dataset_disown(dspp.to_ds, dsflags, FTAG);
	else
	dsl_dataset_rele_flags(dspp.to_ds, dsflags, FTAG);
	return (err);
	}

	if (fromsnap != NULL) {
	zfs_bookmark_phys_t *zb = &dspp.ancestor_zb;
	int fsnamelen;
	if (strpbrk(tosnap, "@#") != NULL)
	fsnamelen = strpbrk(tosnap, "@#") - tosnap;
	else
	fsnamelen = strlen(tosnap);

	/*
	* If the fromsnap is in a different filesystem, then
	* mark the send stream as a clone.
	*/
	if (strncmp(tosnap, fromsnap, fsnamelen) != 0 \|\|
	(fromsnap[fsnamelen] != '@' &&
	fromsnap[fsnamelen] != '#')) {
	dspp.is_clone = B_TRUE;
	}

	if (strchr(fromsnap, '@') != NULL) {
	err = dsl_dataset_hold(dspp.dp, fromsnap, FTAG,
	&fromds);

	if (err != 0) {
	ASSERT3P(fromds, ==, NULL);
	} else {
	/*
	* We need to make a deep copy of the redact
	* snapshots of the from snapshot, because the
	* array will be freed when we evict from_ds.
	*/
	uint64_t *fromredact;
	if (!dsl_dataset_get_uint64_array_feature(
	fromds, SPA_FEATURE_REDACTED_DATASETS,
	&dspp.numfromredactsnaps,
	&fromredact)) {
	dspp.numfromredactsnaps =
	NUM_SNAPS_NOT_REDACTED;
	} else if (dspp.numfromredactsnaps > 0) {
	uint64_t size =
	dspp.numfromredactsnaps *
	sizeof (uint64_t);
	dspp.fromredactsnaps = kmem_zalloc(size,
	KM_SLEEP);
	bcopy(fromredact, dspp.fromredactsnaps,
	size);
	}
	if (!dsl_dataset_is_before(dspp.to_ds, fromds,
	0)) {
	err = SET_ERROR(EXDEV);
	} else {
	zb->zbm_creation_txg =
	dsl_dataset_phys(fromds)->
	ds_creation_txg;
	zb->zbm_creation_time =
	dsl_dataset_phys(fromds)->
	ds_creation_time;
	zb->zbm_guid =
	dsl_dataset_phys(fromds)->ds_guid;
	zb->zbm_redaction_obj = 0;

	if (dsl_dataset_is_zapified(fromds)) {
	(void) zap_lookup(
	dspp.dp->dp_meta_objset,
	fromds->ds_object,
	DS_FIELD_IVSET_GUID, 8, 1,
	&zb->zbm_ivset_guid);
	}
	}
	dsl_dataset_rele(fromds, FTAG);
	}
	} else {
	dspp.numfromredactsnaps = NUM_SNAPS_NOT_REDACTED;
	err = dsl_bookmark_lookup(dspp.dp, fromsnap, dspp.to_ds,
	zb);
	if (err == EXDEV && zb->zbm_redaction_obj != 0 &&
	zb->zbm_guid ==
	dsl_dataset_phys(dspp.to_ds)->ds_guid)
	err = 0;
	}

	if (err == 0) {
	/* dmu_send_impl will call dsl_pool_rele for us. */
	err = dmu_send_impl(&dspp);
	} else {
	dsl_pool_rele(dspp.dp, FTAG);
	}
	} else {
	dspp.numfromredactsnaps = NUM_SNAPS_NOT_REDACTED;
	err = dmu_send_impl(&dspp);
	}
	if (owned)
	dsl_dataset_disown(dspp.to_ds, dsflags, FTAG);
	else
	dsl_dataset_rele_flags(dspp.to_ds, dsflags, FTAG);
	return (err);
	}

	static int
	dmu_adjust_send_estimate_for_indirects(dsl_dataset_t *ds, uint64_t uncompressed,
	uint64_t compressed, boolean_t stream_compressed, uint64_t *sizep)
	{
	int err = 0;
	uint64_t size;
	/*
	* Assume that space (both on-disk and in-stream) is dominated by
	* data. We will adjust for indirect blocks and the copies property,
	* but ignore per-object space used (eg, dnodes and DRR_OBJECT records).
	*/

	uint64_t recordsize;
	uint64_t record_count;
	objset_t *os;
	VERIFY0(dmu_objset_from_ds(ds, &os));

	/* Assume all (uncompressed) blocks are recordsize. */
	if (zfs_override_estimate_recordsize != 0) {
	recordsize = zfs_override_estimate_recordsize;
	} else if (os->os_phys->os_type == DMU_OST_ZVOL) {
	err = dsl_prop_get_int_ds(ds,
	zfs_prop_to_name(ZFS_PROP_VOLBLOCKSIZE), &recordsize);
	} else {
	err = dsl_prop_get_int_ds(ds,
	zfs_prop_to_name(ZFS_PROP_RECORDSIZE), &recordsize);
	}
	if (err != 0)
	return (err);
	record_count = uncompressed / recordsize;

	/*
	* If we're estimating a send size for a compressed stream, use the
	* compressed data size to estimate the stream size. Otherwise, use the
	* uncompressed data size.
	*/
	size = stream_compressed ? compressed : uncompressed;

	/*
	* Subtract out approximate space used by indirect blocks.
	* Assume most space is used by data blocks (non-indirect, non-dnode).
	* Assume no ditto blocks or internal fragmentation.
	*
	* Therefore, space used by indirect blocks is sizeof(blkptr_t) per
	* block.
	*/
	size -= record_count * sizeof (blkptr_t);

	/* Add in the space for the record associated with each block. */
	size += record_count * sizeof (dmu_replay_record_t);

	*sizep = size;

	return (0);
	}

	int
	dmu_send_estimate_fast(dsl_dataset_t origds, dsl_dataset_t fromds,
	zfs_bookmark_phys_t *frombook, boolean_t stream_compressed,
	boolean_t saved, uint64_t *sizep)
	{
	int err;
	dsl_dataset_t *ds = origds;
	uint64_t uncomp, comp;

	ASSERT(dsl_pool_config_held(origds->ds_dir->dd_pool));
	ASSERT(fromds == NULL \|\| frombook == NULL);

	/*
	* If this is a saved send we may actually be sending
	* from the %recv clone used for resuming.
	*/
	if (saved) {
	objset_t *mos = origds->ds_dir->dd_pool->dp_meta_objset;
	uint64_t guid;
	char dsname[ZFS_MAX_DATASET_NAME_LEN + 6];

	dsl_dataset_name(origds, dsname);
	(void) strcat(dsname, "/");
	(void) strcat(dsname, recv_clone_name);

	err = dsl_dataset_hold(origds->ds_dir->dd_pool,
	dsname, FTAG, &ds);
	if (err != ENOENT && err != 0) {
	return (err);
	} else if (err == ENOENT) {
	ds = origds;
	}

	/* check that this dataset has partially received data */
	err = zap_lookup(mos, ds->ds_object,
	DS_FIELD_RESUME_TOGUID, 8, 1, &guid);
	if (err != 0) {
	err = SET_ERROR(err == ENOENT ? EINVAL : err);
	goto out;
	}

	err = zap_lookup(mos, ds->ds_object,
	DS_FIELD_RESUME_TONAME, 1, sizeof (dsname), dsname);
	if (err != 0) {
	err = SET_ERROR(err == ENOENT ? EINVAL : err);
	goto out;
	}
	}

	/* tosnap must be a snapshot or the target of a saved send */
	if (!ds->ds_is_snapshot && ds == origds)
	return (SET_ERROR(EINVAL));

	if (fromds != NULL) {
	uint64_t used;
	if (!fromds->ds_is_snapshot) {
	err = SET_ERROR(EINVAL);
	goto out;
	}

	if (!dsl_dataset_is_before(ds, fromds, 0)) {
	err = SET_ERROR(EXDEV);
	goto out;
	}

	err = dsl_dataset_space_written(fromds, ds, &used, &comp,
	&uncomp);
	if (err != 0)
	goto out;
	} else if (frombook != NULL) {
	uint64_t used;
	err = dsl_dataset_space_written_bookmark(frombook, ds, &used,
	&comp, &uncomp);
	if (err != 0)
	goto out;
	} else {
	uncomp = dsl_dataset_phys(ds)->ds_uncompressed_bytes;
	comp = dsl_dataset_phys(ds)->ds_compressed_bytes;
	}

	err = dmu_adjust_send_estimate_for_indirects(ds, uncomp, comp,
	stream_compressed, sizep);
	/*
	* Add the size of the BEGIN and END records to the estimate.
	*/
	sizep += 2 sizeof (dmu_replay_record_t);

	out:
	if (ds != origds)
	dsl_dataset_rele(ds, FTAG);
	return (err);
	}

	/* BEGIN CSTYLED */
	ZFS_MODULE_PARAM(zfs_send, zfs_send_, corrupt_data, INT, ZMOD_RW,
	"Allow sending corrupt data");

	ZFS_MODULE_PARAM(zfs_send, zfs_send_, queue_length, INT, ZMOD_RW,
	"Maximum send queue length");

	ZFS_MODULE_PARAM(zfs_send, zfs_send_, unmodified_spill_blocks, INT, ZMOD_RW,
	"Send unmodified spill blocks");

	ZFS_MODULE_PARAM(zfs_send, zfs_send_, no_prefetch_queue_length, INT, ZMOD_RW,
	"Maximum send queue length for non-prefetch queues");

	ZFS_MODULE_PARAM(zfs_send, zfs_send_, queue_ff, INT, ZMOD_RW,
	"Send queue fill fraction");

	ZFS_MODULE_PARAM(zfs_send, zfs_send_, no_prefetch_queue_ff, INT, ZMOD_RW,
	"Send queue fill fraction for non-prefetch queues");

	ZFS_MODULE_PARAM(zfs_send, zfs_, override_estimate_recordsize, INT, ZMOD_RW,
	"Override block size estimate with fixed size");
	/* END CSTYLED */
	diff --git a/sys/contrib/openzfs/module/zfs/dnode.c b/sys/contrib/openzfs/module/zfs/dnode.c
	index 7f741542ce02..7044c1fc6342 100644
	--- a/sys/contrib/openzfs/module/zfs/dnode.c
	+++ b/sys/contrib/openzfs/module/zfs/dnode.c
	@@ -1,2580 +1,2600 @@
	/*
	* 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_type[0], sizeof (dn->dn_next_type));
	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, (u_longlong_t)dn->dn_object,
	(u_longlong_t)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));

	/* 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, 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;

	/*
	* 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));
	}

	+/*
	+ * Checks if the dnode contains any uncommitted dirty records.
	+ */
	+boolean_t
	+dnode_is_dirty(dnode_t *dn)
	+{
	+ mutex_enter(&dn->dn_mtx);
	+
	+ for (int i = 0; i < TXG_SIZE; i++) {
	+ if (multilist_link_active(&dn->dn_dirty_link[i])) {
	+ mutex_exit(&dn->dn_mtx);
	+ return (B_TRUE);
	+ }
	+ }
	+
	+ mutex_exit(&dn->dn_mtx);
	+
	+ return (B_FALSE);
	+}
	+
	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",
	(u_longlong_t)dn->dn_object, (u_longlong_t)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",
	(u_longlong_t)blkid, (u_longlong_t)nblks,
	(u_longlong_t)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_prop.c b/sys/contrib/openzfs/module/zfs/dsl_prop.c
	index f6ff9ae47192..dfa04d7681be 100644
	--- a/sys/contrib/openzfs/module/zfs/dsl_prop.c
	+++ b/sys/contrib/openzfs/module/zfs/dsl_prop.c
	@@ -1,1287 +1,1287 @@
	/*
	* 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) 2013 Martin Matuska. All rights reserved.
	* Copyright 2019 Joyent, Inc.
	*/

	#include <sys/zfs_context.h>
	#include <sys/dmu.h>
	#include <sys/dmu_objset.h>
	#include <sys/dmu_tx.h>
	#include <sys/dsl_dataset.h>
	#include <sys/dsl_dir.h>
	#include <sys/dsl_prop.h>
	#include <sys/dsl_synctask.h>
	#include <sys/spa.h>
	#include <sys/zap.h>
	#include <sys/fs/zfs.h>

	#include "zfs_prop.h"

	#define ZPROP_INHERIT_SUFFIX "$inherit"
	#define ZPROP_RECVD_SUFFIX "$recvd"

	static int
	dodefault(zfs_prop_t prop, int intsz, int numints, void *buf)
	{
	/*
	* The setonce properties are read-only, BUT they still
	* have a default value that can be used as the initial
	* value.
	*/
	if (prop == ZPROP_INVAL \|\|
	(zfs_prop_readonly(prop) && !zfs_prop_setonce(prop)))
	return (SET_ERROR(ENOENT));

	if (zfs_prop_get_type(prop) == PROP_TYPE_STRING) {
	if (intsz != 1)
	return (SET_ERROR(EOVERFLOW));
	(void) strncpy(buf, zfs_prop_default_string(prop),
	numints);
	} else {
	if (intsz != 8 \|\| numints < 1)
	return (SET_ERROR(EOVERFLOW));

	(uint64_t )buf = zfs_prop_default_numeric(prop);
	}

	return (0);
	}

	int
	dsl_prop_get_dd(dsl_dir_t dd, const char propname,
	int intsz, int numints, void buf, char setpoint, boolean_t snapshot)
	{
	int err;
	dsl_dir_t *target = dd;
	objset_t *mos = dd->dd_pool->dp_meta_objset;
	zfs_prop_t prop;
	boolean_t inheritable;
	boolean_t inheriting = B_FALSE;
	char *inheritstr;
	char *recvdstr;

	ASSERT(dsl_pool_config_held(dd->dd_pool));

	if (setpoint)
	setpoint[0] = '\0';

	prop = zfs_name_to_prop(propname);
	inheritable = (prop == ZPROP_INVAL \|\| zfs_prop_inheritable(prop));
	inheritstr = kmem_asprintf("%s%s", propname, ZPROP_INHERIT_SUFFIX);
	recvdstr = kmem_asprintf("%s%s", propname, ZPROP_RECVD_SUFFIX);

	/*
	* Note: dd may become NULL, therefore we shouldn't dereference it
	* after this loop.
	*/
	for (; dd != NULL; dd = dd->dd_parent) {
	if (dd != target \|\| snapshot) {
	if (!inheritable) {
	err = SET_ERROR(ENOENT);
	break;
	}
	inheriting = B_TRUE;
	}

	/* Check for a local value. */
	err = zap_lookup(mos, dsl_dir_phys(dd)->dd_props_zapobj,
	propname, intsz, numints, buf);
	if (err != ENOENT) {
	if (setpoint != NULL && err == 0)
	dsl_dir_name(dd, setpoint);
	break;
	}

	/*
	* Skip the check for a received value if there is an explicit
	* inheritance entry.
	*/
	err = zap_contains(mos, dsl_dir_phys(dd)->dd_props_zapobj,
	inheritstr);
	if (err != 0 && err != ENOENT)
	break;

	if (err == ENOENT) {
	/* Check for a received value. */
	err = zap_lookup(mos, dsl_dir_phys(dd)->dd_props_zapobj,
	recvdstr, intsz, numints, buf);
	if (err != ENOENT) {
	if (setpoint != NULL && err == 0) {
	if (inheriting) {
	dsl_dir_name(dd, setpoint);
	} else {
	(void) strlcpy(setpoint,
	ZPROP_SOURCE_VAL_RECVD,
	MAXNAMELEN);
	}
	}
	break;
	}
	}

	/*
	* If we found an explicit inheritance entry, err is zero even
	* though we haven't yet found the value, so reinitializing err
	* at the end of the loop (instead of at the beginning) ensures
	* that err has a valid post-loop value.
	*/
	err = SET_ERROR(ENOENT);
	}

	if (err == ENOENT)
	err = dodefault(prop, intsz, numints, buf);

	kmem_strfree(inheritstr);
	kmem_strfree(recvdstr);

	return (err);
	}

	int
	dsl_prop_get_ds(dsl_dataset_t ds, const char propname,
	int intsz, int numints, void buf, char setpoint)
	{
	zfs_prop_t prop = zfs_name_to_prop(propname);
	boolean_t inheritable;
	uint64_t zapobj;

	ASSERT(dsl_pool_config_held(ds->ds_dir->dd_pool));
	inheritable = (prop == ZPROP_INVAL \|\| zfs_prop_inheritable(prop));
	zapobj = dsl_dataset_phys(ds)->ds_props_obj;

	if (zapobj != 0) {
	objset_t *mos = ds->ds_dir->dd_pool->dp_meta_objset;
	int err;

	ASSERT(ds->ds_is_snapshot);

	/* Check for a local value. */
	err = zap_lookup(mos, zapobj, propname, intsz, numints, buf);
	if (err != ENOENT) {
	if (setpoint != NULL && err == 0)
	dsl_dataset_name(ds, setpoint);
	return (err);
	}

	/*
	* Skip the check for a received value if there is an explicit
	* inheritance entry.
	*/
	if (inheritable) {
	char *inheritstr = kmem_asprintf("%s%s", propname,
	ZPROP_INHERIT_SUFFIX);
	err = zap_contains(mos, zapobj, inheritstr);
	kmem_strfree(inheritstr);
	if (err != 0 && err != ENOENT)
	return (err);
	}

	if (err == ENOENT) {
	/* Check for a received value. */
	char *recvdstr = kmem_asprintf("%s%s", propname,
	ZPROP_RECVD_SUFFIX);
	err = zap_lookup(mos, zapobj, recvdstr,
	intsz, numints, buf);
	kmem_strfree(recvdstr);
	if (err != ENOENT) {
	if (setpoint != NULL && err == 0)
	(void) strlcpy(setpoint,
	ZPROP_SOURCE_VAL_RECVD,
	MAXNAMELEN);
	return (err);
	}
	}
	}

	return (dsl_prop_get_dd(ds->ds_dir, propname,
	intsz, numints, buf, setpoint, ds->ds_is_snapshot));
	}

	static dsl_prop_record_t *
	dsl_prop_record_find(dsl_dir_t dd, const char propname)
	{
	dsl_prop_record_t *pr = NULL;

	ASSERT(MUTEX_HELD(&dd->dd_lock));

	for (pr = list_head(&dd->dd_props);
	pr != NULL; pr = list_next(&dd->dd_props, pr)) {
	if (strcmp(pr->pr_propname, propname) == 0)
	break;
	}

	return (pr);
	}

	static dsl_prop_record_t *
	dsl_prop_record_create(dsl_dir_t dd, const char propname)
	{
	dsl_prop_record_t *pr;

	ASSERT(MUTEX_HELD(&dd->dd_lock));

	pr = kmem_alloc(sizeof (dsl_prop_record_t), KM_SLEEP);
	pr->pr_propname = spa_strdup(propname);
	list_create(&pr->pr_cbs, sizeof (dsl_prop_cb_record_t),
	offsetof(dsl_prop_cb_record_t, cbr_pr_node));
	list_insert_head(&dd->dd_props, pr);

	return (pr);
	}

	void
	dsl_prop_init(dsl_dir_t *dd)
	{
	list_create(&dd->dd_props, sizeof (dsl_prop_record_t),
	offsetof(dsl_prop_record_t, pr_node));
	}

	void
	dsl_prop_fini(dsl_dir_t *dd)
	{
	dsl_prop_record_t *pr;

	while ((pr = list_remove_head(&dd->dd_props)) != NULL) {
	list_destroy(&pr->pr_cbs);
	spa_strfree((char *)pr->pr_propname);
	kmem_free(pr, sizeof (dsl_prop_record_t));
	}
	list_destroy(&dd->dd_props);
	}

	/*
	* Register interest in the named property. We'll call the callback
	* once to notify it of the current property value, and again each time
	* the property changes, until this callback is unregistered.
	*
	* Return 0 on success, errno if the prop is not an integer value.
	*/
	int
	dsl_prop_register(dsl_dataset_t ds, const char propname,
	dsl_prop_changed_cb_t callback, void cbarg)
	{
	dsl_dir_t *dd = ds->ds_dir;
	uint64_t value;
	dsl_prop_record_t *pr;
	dsl_prop_cb_record_t *cbr;
	int err;
	dsl_pool_t *dp __maybe_unused = dd->dd_pool;

	ASSERT(dsl_pool_config_held(dp));

	err = dsl_prop_get_int_ds(ds, propname, &value);
	if (err != 0)
	return (err);

	cbr = kmem_alloc(sizeof (dsl_prop_cb_record_t), KM_SLEEP);
	cbr->cbr_ds = ds;
	cbr->cbr_func = callback;
	cbr->cbr_arg = cbarg;

	mutex_enter(&dd->dd_lock);
	pr = dsl_prop_record_find(dd, propname);
	if (pr == NULL)
	pr = dsl_prop_record_create(dd, propname);
	cbr->cbr_pr = pr;
	list_insert_head(&pr->pr_cbs, cbr);
	list_insert_head(&ds->ds_prop_cbs, cbr);
	mutex_exit(&dd->dd_lock);

	cbr->cbr_func(cbr->cbr_arg, value);
	return (0);
	}

	int
	dsl_prop_get(const char dsname, const char propname,
	int intsz, int numints, void buf, char setpoint)
	{
	objset_t *os;
	int error;

	error = dmu_objset_hold(dsname, FTAG, &os);
	if (error != 0)
	return (error);

	error = dsl_prop_get_ds(dmu_objset_ds(os), propname,
	intsz, numints, buf, setpoint);

	dmu_objset_rele(os, FTAG);
	return (error);
	}

	/*
	* Get the current property value. It may have changed by the time this
	* function returns, so it is NOT safe to follow up with
	* dsl_prop_register() and assume that the value has not changed in
	* between.
	*
	* Return 0 on success, ENOENT if ddname is invalid.
	*/
	int
	dsl_prop_get_integer(const char ddname, const char propname,
	uint64_t valuep, char setpoint)
	{
	return (dsl_prop_get(ddname, propname, 8, 1, valuep, setpoint));
	}

	int
	dsl_prop_get_int_ds(dsl_dataset_t ds, const char propname,
	uint64_t *valuep)
	{
	return (dsl_prop_get_ds(ds, propname, 8, 1, valuep, NULL));
	}

	/*
	* Predict the effective value of the given special property if it were set with
	* the given value and source. This is not a general purpose function. It exists
	* only to handle the special requirements of the quota and reservation
	* properties. The fact that these properties are non-inheritable greatly
	* simplifies the prediction logic.
	*
	* Returns 0 on success, a positive error code on failure, or -1 if called with
	* a property not handled by this function.
	*/
	int
	dsl_prop_predict(dsl_dir_t dd, const char propname,
	zprop_source_t source, uint64_t value, uint64_t *newvalp)
	{
	zfs_prop_t prop = zfs_name_to_prop(propname);
	objset_t *mos;
	uint64_t zapobj;
	uint64_t version;
	char *recvdstr;
	int err = 0;

	switch (prop) {
	case ZFS_PROP_QUOTA:
	case ZFS_PROP_RESERVATION:
	case ZFS_PROP_REFQUOTA:
	case ZFS_PROP_REFRESERVATION:
	break;
	default:
	return (-1);
	}

	mos = dd->dd_pool->dp_meta_objset;
	zapobj = dsl_dir_phys(dd)->dd_props_zapobj;
	recvdstr = kmem_asprintf("%s%s", propname, ZPROP_RECVD_SUFFIX);

	version = spa_version(dd->dd_pool->dp_spa);
	if (version < SPA_VERSION_RECVD_PROPS) {
	if (source & ZPROP_SRC_NONE)
	source = ZPROP_SRC_NONE;
	else if (source & ZPROP_SRC_RECEIVED)
	source = ZPROP_SRC_LOCAL;
	}

	switch ((int)source) {
	case ZPROP_SRC_NONE:
	/* Revert to the received value, if any. */
	err = zap_lookup(mos, zapobj, recvdstr, 8, 1, newvalp);
	if (err == ENOENT)
	*newvalp = 0;
	break;
	case ZPROP_SRC_LOCAL:
	*newvalp = value;
	break;
	case ZPROP_SRC_RECEIVED:
	/*
	* If there's no local setting, then the new received value will
	* be the effective value.
	*/
	err = zap_lookup(mos, zapobj, propname, 8, 1, newvalp);
	if (err == ENOENT)
	*newvalp = value;
	break;
	case (ZPROP_SRC_NONE \| ZPROP_SRC_RECEIVED):
	/*
	* We're clearing the received value, so the local setting (if
	* it exists) remains the effective value.
	*/
	err = zap_lookup(mos, zapobj, propname, 8, 1, newvalp);
	if (err == ENOENT)
	*newvalp = 0;
	break;
	default:
	panic("unexpected property source: %d", source);
	}

	kmem_strfree(recvdstr);

	if (err == ENOENT)
	return (0);

	return (err);
	}

	/*
	* Unregister this callback. Return 0 on success, ENOENT if ddname is
	* invalid, or ENOMSG if no matching callback registered.
	*
	* NOTE: This function is no longer used internally but has been preserved
	* to prevent breaking external consumers (Lustre, etc).
	*/
	int
	dsl_prop_unregister(dsl_dataset_t ds, const char propname,
	dsl_prop_changed_cb_t callback, void cbarg)
	{
	dsl_dir_t *dd = ds->ds_dir;
	dsl_prop_cb_record_t *cbr;

	mutex_enter(&dd->dd_lock);
	for (cbr = list_head(&ds->ds_prop_cbs);
	cbr; cbr = list_next(&ds->ds_prop_cbs, cbr)) {
	if (cbr->cbr_ds == ds &&
	cbr->cbr_func == callback &&
	cbr->cbr_arg == cbarg &&
	strcmp(cbr->cbr_pr->pr_propname, propname) == 0)
	break;
	}

	if (cbr == NULL) {
	mutex_exit(&dd->dd_lock);
	return (SET_ERROR(ENOMSG));
	}

	list_remove(&ds->ds_prop_cbs, cbr);
	list_remove(&cbr->cbr_pr->pr_cbs, cbr);
	mutex_exit(&dd->dd_lock);
	kmem_free(cbr, sizeof (dsl_prop_cb_record_t));

	return (0);
	}

	/*
	* Unregister all callbacks that are registered with the
	* given callback argument.
	*/
	void
	dsl_prop_unregister_all(dsl_dataset_t ds, void cbarg)
	{
	dsl_prop_cb_record_t cbr, next_cbr;

	dsl_dir_t *dd = ds->ds_dir;

	mutex_enter(&dd->dd_lock);
	next_cbr = list_head(&ds->ds_prop_cbs);
	while (next_cbr != NULL) {
	cbr = next_cbr;
	next_cbr = list_next(&ds->ds_prop_cbs, cbr);
	if (cbr->cbr_arg == cbarg) {
	list_remove(&ds->ds_prop_cbs, cbr);
	list_remove(&cbr->cbr_pr->pr_cbs, cbr);
	kmem_free(cbr, sizeof (dsl_prop_cb_record_t));
	}
	}
	mutex_exit(&dd->dd_lock);
	}

	boolean_t
	dsl_prop_hascb(dsl_dataset_t *ds)
	{
	return (!list_is_empty(&ds->ds_prop_cbs));
	}

	/* ARGSUSED */
	static int
	dsl_prop_notify_all_cb(dsl_pool_t dp, dsl_dataset_t ds, void *arg)
	{
	dsl_dir_t *dd = ds->ds_dir;
	dsl_prop_record_t *pr;
	dsl_prop_cb_record_t *cbr;

	mutex_enter(&dd->dd_lock);
	for (pr = list_head(&dd->dd_props);
	pr; pr = list_next(&dd->dd_props, pr)) {
	for (cbr = list_head(&pr->pr_cbs); cbr;
	cbr = list_next(&pr->pr_cbs, cbr)) {
	uint64_t value;

	/*
	* Callback entries do not have holds on their
	* datasets so that datasets with registered
	* callbacks are still eligible for eviction.
	* Unlike operations to update properties on a
	* single dataset, we are performing a recursive
	* descent of related head datasets. The caller
	* of this function only has a dataset hold on
	* the passed in head dataset, not the snapshots
	* associated with this dataset. Without a hold,
	* the dataset pointer within callback records
	* for snapshots can be invalidated by eviction
	* at any time.
	*
	* Use dsl_dataset_try_add_ref() to verify
	* that the dataset for a snapshot has not
	* begun eviction processing and to prevent
	* eviction from occurring for the duration of
	* the callback. If the hold attempt fails,
	* this object is already being evicted and the
	* callback can be safely ignored.
	*/
	if (ds != cbr->cbr_ds &&
	!dsl_dataset_try_add_ref(dp, cbr->cbr_ds, FTAG))
	continue;

	if (dsl_prop_get_ds(cbr->cbr_ds,
	cbr->cbr_pr->pr_propname, sizeof (value), 1,
	&value, NULL) == 0)
	cbr->cbr_func(cbr->cbr_arg, value);

	if (ds != cbr->cbr_ds)
	dsl_dataset_rele(cbr->cbr_ds, FTAG);
	}
	}
	mutex_exit(&dd->dd_lock);

	return (0);
	}

	/*
	* Update all property values for ddobj & its descendants. This is used
	* when renaming the dir.
	*/
	void
	dsl_prop_notify_all(dsl_dir_t *dd)
	{
	dsl_pool_t *dp = dd->dd_pool;
	ASSERT(RRW_WRITE_HELD(&dp->dp_config_rwlock));
	(void) dmu_objset_find_dp(dp, dd->dd_object, dsl_prop_notify_all_cb,
	NULL, DS_FIND_CHILDREN);
	}

	static void
	dsl_prop_changed_notify(dsl_pool_t *dp, uint64_t ddobj,
	const char *propname, uint64_t value, int first)
	{
	dsl_dir_t *dd;
	dsl_prop_record_t *pr;
	dsl_prop_cb_record_t *cbr;
	objset_t *mos = dp->dp_meta_objset;
	zap_cursor_t zc;
	zap_attribute_t *za;
	int err;

	ASSERT(RRW_WRITE_HELD(&dp->dp_config_rwlock));
	err = dsl_dir_hold_obj(dp, ddobj, NULL, FTAG, &dd);
	if (err)
	return;

	if (!first) {
	/*
	* If the prop is set here, then this change is not
	* being inherited here or below; stop the recursion.
	*/
	err = zap_contains(mos, dsl_dir_phys(dd)->dd_props_zapobj,
	propname);
	if (err == 0) {
	dsl_dir_rele(dd, FTAG);
	return;
	}
	ASSERT3U(err, ==, ENOENT);
	}

	mutex_enter(&dd->dd_lock);
	pr = dsl_prop_record_find(dd, propname);
	if (pr != NULL) {
	for (cbr = list_head(&pr->pr_cbs); cbr;
	cbr = list_next(&pr->pr_cbs, cbr)) {
	uint64_t propobj;

	/*
	* cbr->cbr_ds may be invalidated due to eviction,
	* requiring the use of dsl_dataset_try_add_ref().
	* See comment block in dsl_prop_notify_all_cb()
	* for details.
	*/
	if (!dsl_dataset_try_add_ref(dp, cbr->cbr_ds, FTAG))
	continue;

	propobj = dsl_dataset_phys(cbr->cbr_ds)->ds_props_obj;

	/*
	* If the property is not set on this ds, then it is
	* inherited here; call the callback.
	*/
	if (propobj == 0 \|\|
	zap_contains(mos, propobj, propname) != 0)
	cbr->cbr_func(cbr->cbr_arg, value);

	dsl_dataset_rele(cbr->cbr_ds, FTAG);
	}
	}
	mutex_exit(&dd->dd_lock);

	za = kmem_alloc(sizeof (zap_attribute_t), KM_SLEEP);
	for (zap_cursor_init(&zc, mos,
	dsl_dir_phys(dd)->dd_child_dir_zapobj);
	zap_cursor_retrieve(&zc, za) == 0;
	zap_cursor_advance(&zc)) {
	dsl_prop_changed_notify(dp, za->za_first_integer,
	propname, value, FALSE);
	}
	kmem_free(za, sizeof (zap_attribute_t));
	zap_cursor_fini(&zc);
	dsl_dir_rele(dd, FTAG);
	}

	void
	dsl_prop_set_sync_impl(dsl_dataset_t ds, const char propname,
	zprop_source_t source, int intsz, int numints, const void *value,
	dmu_tx_t *tx)
	{
	objset_t *mos = ds->ds_dir->dd_pool->dp_meta_objset;
	uint64_t zapobj, intval, dummy, count;
	int isint;
	char valbuf[32];
	const char *valstr = NULL;
	char *inheritstr;
	char *recvdstr;
	char *tbuf = NULL;
	int err;
	uint64_t version = spa_version(ds->ds_dir->dd_pool->dp_spa);

	isint = (dodefault(zfs_name_to_prop(propname), 8, 1, &intval) == 0);

	if (ds->ds_is_snapshot) {
	ASSERT(version >= SPA_VERSION_SNAP_PROPS);
	if (dsl_dataset_phys(ds)->ds_props_obj == 0 &&
	(source & ZPROP_SRC_NONE) == 0) {
	dmu_buf_will_dirty(ds->ds_dbuf, tx);
	dsl_dataset_phys(ds)->ds_props_obj =
	zap_create(mos,
	DMU_OT_DSL_PROPS, DMU_OT_NONE, 0, tx);
	}
	zapobj = dsl_dataset_phys(ds)->ds_props_obj;
	} else {
	zapobj = dsl_dir_phys(ds->ds_dir)->dd_props_zapobj;
	}

	/* If we are removing objects from a non-existent ZAP just return */
	if (zapobj == 0)
	return;

	if (version < SPA_VERSION_RECVD_PROPS) {
	if (source & ZPROP_SRC_NONE)
	source = ZPROP_SRC_NONE;
	else if (source & ZPROP_SRC_RECEIVED)
	source = ZPROP_SRC_LOCAL;
	}

	inheritstr = kmem_asprintf("%s%s", propname, ZPROP_INHERIT_SUFFIX);
	recvdstr = kmem_asprintf("%s%s", propname, ZPROP_RECVD_SUFFIX);

	switch ((int)source) {
	case ZPROP_SRC_NONE:
	/*
	* revert to received value, if any (inherit -S)
	* - remove propname
	* - remove propname$inherit
	*/
	err = zap_remove(mos, zapobj, propname, tx);
	ASSERT(err == 0 \|\| err == ENOENT);
	err = zap_remove(mos, zapobj, inheritstr, tx);
	ASSERT(err == 0 \|\| err == ENOENT);
	break;
	case ZPROP_SRC_LOCAL:
	/*
	* remove propname$inherit
	* set propname -> value
	*/
	err = zap_remove(mos, zapobj, inheritstr, tx);
	ASSERT(err == 0 \|\| err == ENOENT);
	VERIFY0(zap_update(mos, zapobj, propname,
	intsz, numints, value, tx));
	break;
	case ZPROP_SRC_INHERITED:
	/*
	* explicitly inherit
	* - remove propname
	* - set propname$inherit
	*/
	err = zap_remove(mos, zapobj, propname, tx);
	ASSERT(err == 0 \|\| err == ENOENT);
	if (version >= SPA_VERSION_RECVD_PROPS &&
	dsl_prop_get_int_ds(ds, ZPROP_HAS_RECVD, &dummy) == 0) {
	dummy = 0;
	VERIFY0(zap_update(mos, zapobj, inheritstr,
	8, 1, &dummy, tx));
	}
	break;
	case ZPROP_SRC_RECEIVED:
	/*
	* set propname$recvd -> value
	*/
	err = zap_update(mos, zapobj, recvdstr,
	intsz, numints, value, tx);
	ASSERT(err == 0);
	break;
	case (ZPROP_SRC_NONE \| ZPROP_SRC_LOCAL \| ZPROP_SRC_RECEIVED):
	/*
	* clear local and received settings
	* - remove propname
	* - remove propname$inherit
	* - remove propname$recvd
	*/
	err = zap_remove(mos, zapobj, propname, tx);
	ASSERT(err == 0 \|\| err == ENOENT);
	err = zap_remove(mos, zapobj, inheritstr, tx);
	ASSERT(err == 0 \|\| err == ENOENT);
	- /* FALLTHRU */
	+ fallthrough;
	case (ZPROP_SRC_NONE \| ZPROP_SRC_RECEIVED):
	/*
	* remove propname$recvd
	*/
	err = zap_remove(mos, zapobj, recvdstr, tx);
	ASSERT(err == 0 \|\| err == ENOENT);
	break;
	default:
	cmn_err(CE_PANIC, "unexpected property source: %d", source);
	}

	kmem_strfree(inheritstr);
	kmem_strfree(recvdstr);

	/*
	* If we are left with an empty snap zap we can destroy it.
	* This will prevent unnecessary calls to zap_lookup() in
	* the "zfs list" and "zfs get" code paths.
	*/
	if (ds->ds_is_snapshot &&
	zap_count(mos, zapobj, &count) == 0 && count == 0) {
	dmu_buf_will_dirty(ds->ds_dbuf, tx);
	dsl_dataset_phys(ds)->ds_props_obj = 0;
	zap_destroy(mos, zapobj, tx);
	}

	if (isint) {
	VERIFY0(dsl_prop_get_int_ds(ds, propname, &intval));

	if (ds->ds_is_snapshot) {
	dsl_prop_cb_record_t *cbr;
	/*
	* It's a snapshot; nothing can inherit this
	* property, so just look for callbacks on this
	* ds here.
	*/
	mutex_enter(&ds->ds_dir->dd_lock);
	for (cbr = list_head(&ds->ds_prop_cbs); cbr;
	cbr = list_next(&ds->ds_prop_cbs, cbr)) {
	if (strcmp(cbr->cbr_pr->pr_propname,
	propname) == 0)
	cbr->cbr_func(cbr->cbr_arg, intval);
	}
	mutex_exit(&ds->ds_dir->dd_lock);
	} else {
	dsl_prop_changed_notify(ds->ds_dir->dd_pool,
	ds->ds_dir->dd_object, propname, intval, TRUE);
	}

	(void) snprintf(valbuf, sizeof (valbuf),
	"%lld", (longlong_t)intval);
	valstr = valbuf;
	} else {
	if (source == ZPROP_SRC_LOCAL) {
	valstr = value;
	} else {
	tbuf = kmem_alloc(ZAP_MAXVALUELEN, KM_SLEEP);
	if (dsl_prop_get_ds(ds, propname, 1,
	ZAP_MAXVALUELEN, tbuf, NULL) == 0)
	valstr = tbuf;
	}
	}

	spa_history_log_internal_ds(ds, (source == ZPROP_SRC_NONE \|\|
	source == ZPROP_SRC_INHERITED) ? "inherit" : "set", tx,
	"%s=%s", propname, (valstr == NULL ? "" : valstr));

	if (tbuf != NULL)
	kmem_free(tbuf, ZAP_MAXVALUELEN);
	}

	int
	dsl_prop_set_int(const char dsname, const char propname,
	zprop_source_t source, uint64_t value)
	{
	nvlist_t *nvl = fnvlist_alloc();
	int error;

	fnvlist_add_uint64(nvl, propname, value);
	error = dsl_props_set(dsname, source, nvl);
	fnvlist_free(nvl);
	return (error);
	}

	int
	dsl_prop_set_string(const char dsname, const char propname,
	zprop_source_t source, const char *value)
	{
	nvlist_t *nvl = fnvlist_alloc();
	int error;

	fnvlist_add_string(nvl, propname, value);
	error = dsl_props_set(dsname, source, nvl);
	fnvlist_free(nvl);
	return (error);
	}

	int
	dsl_prop_inherit(const char dsname, const char propname,
	zprop_source_t source)
	{
	nvlist_t *nvl = fnvlist_alloc();
	int error;

	fnvlist_add_boolean(nvl, propname);
	error = dsl_props_set(dsname, source, nvl);
	fnvlist_free(nvl);
	return (error);
	}

	int
	dsl_props_set_check(void arg, dmu_tx_t tx)
	{
	dsl_props_set_arg_t *dpsa = arg;
	dsl_pool_t *dp = dmu_tx_pool(tx);
	dsl_dataset_t *ds;
	uint64_t version;
	nvpair_t *elem = NULL;
	int err;

	err = dsl_dataset_hold(dp, dpsa->dpsa_dsname, FTAG, &ds);
	if (err != 0)
	return (err);

	version = spa_version(ds->ds_dir->dd_pool->dp_spa);
	while ((elem = nvlist_next_nvpair(dpsa->dpsa_props, elem)) != NULL) {
	if (strlen(nvpair_name(elem)) >= ZAP_MAXNAMELEN) {
	dsl_dataset_rele(ds, FTAG);
	return (SET_ERROR(ENAMETOOLONG));
	}
	if (nvpair_type(elem) == DATA_TYPE_STRING) {
	char *valstr = fnvpair_value_string(elem);
	if (strlen(valstr) >= (version <
	SPA_VERSION_STMF_PROP ?
	ZAP_OLDMAXVALUELEN : ZAP_MAXVALUELEN)) {
	dsl_dataset_rele(ds, FTAG);
	return (SET_ERROR(E2BIG));
	}
	}
	}

	if (ds->ds_is_snapshot && version < SPA_VERSION_SNAP_PROPS) {
	dsl_dataset_rele(ds, FTAG);
	return (SET_ERROR(ENOTSUP));
	}
	dsl_dataset_rele(ds, FTAG);
	return (0);
	}

	void
	dsl_props_set_sync_impl(dsl_dataset_t *ds, zprop_source_t source,
	nvlist_t props, dmu_tx_t tx)
	{
	nvpair_t *elem = NULL;

	while ((elem = nvlist_next_nvpair(props, elem)) != NULL) {
	nvpair_t *pair = elem;
	const char *name = nvpair_name(pair);

	if (nvpair_type(pair) == DATA_TYPE_NVLIST) {
	/*
	* This usually happens when we reuse the nvlist_t data
	* returned by the counterpart dsl_prop_get_all_impl().
	* For instance we do this to restore the original
	* received properties when an error occurs in the
	* zfs_ioc_recv() codepath.
	*/
	nvlist_t *attrs = fnvpair_value_nvlist(pair);
	pair = fnvlist_lookup_nvpair(attrs, ZPROP_VALUE);
	}

	if (nvpair_type(pair) == DATA_TYPE_STRING) {
	const char *value = fnvpair_value_string(pair);
	dsl_prop_set_sync_impl(ds, name,
	source, 1, strlen(value) + 1, value, tx);
	} else if (nvpair_type(pair) == DATA_TYPE_UINT64) {
	uint64_t intval = fnvpair_value_uint64(pair);
	dsl_prop_set_sync_impl(ds, name,
	source, sizeof (intval), 1, &intval, tx);
	} else if (nvpair_type(pair) == DATA_TYPE_BOOLEAN) {
	dsl_prop_set_sync_impl(ds, name,
	source, 0, 0, NULL, tx);
	} else {
	panic("invalid nvpair type");
	}
	}
	}

	void
	dsl_props_set_sync(void arg, dmu_tx_t tx)
	{
	dsl_props_set_arg_t *dpsa = arg;
	dsl_pool_t *dp = dmu_tx_pool(tx);
	dsl_dataset_t *ds;

	VERIFY0(dsl_dataset_hold(dp, dpsa->dpsa_dsname, FTAG, &ds));
	dsl_props_set_sync_impl(ds, dpsa->dpsa_source, dpsa->dpsa_props, tx);
	dsl_dataset_rele(ds, FTAG);
	}

	/*
	* All-or-nothing; if any prop can't be set, nothing will be modified.
	*/
	int
	dsl_props_set(const char dsname, zprop_source_t source, nvlist_t props)
	{
	dsl_props_set_arg_t dpsa;
	int nblks = 0;

	dpsa.dpsa_dsname = dsname;
	dpsa.dpsa_source = source;
	dpsa.dpsa_props = props;

	/*
	* If the source includes NONE, then we will only be removing entries
	* from the ZAP object. In that case don't check for ENOSPC.
	*/
	if ((source & ZPROP_SRC_NONE) == 0)
	nblks = 2 * fnvlist_num_pairs(props);

	return (dsl_sync_task(dsname, dsl_props_set_check, dsl_props_set_sync,
	&dpsa, nblks, ZFS_SPACE_CHECK_RESERVED));
	}

	typedef enum dsl_prop_getflags {
	DSL_PROP_GET_INHERITING = 0x1, /* searching parent of target ds */
	DSL_PROP_GET_SNAPSHOT = 0x2, /* snapshot dataset */
	DSL_PROP_GET_LOCAL = 0x4, /* local properties */
	DSL_PROP_GET_RECEIVED = 0x8, /* received properties */
	} dsl_prop_getflags_t;

	static int
	dsl_prop_get_all_impl(objset_t *mos, uint64_t propobj,
	const char setpoint, dsl_prop_getflags_t flags, nvlist_t nv)
	{
	zap_cursor_t zc;
	zap_attribute_t za;
	int err = 0;

	for (zap_cursor_init(&zc, mos, propobj);
	(err = zap_cursor_retrieve(&zc, &za)) == 0;
	zap_cursor_advance(&zc)) {
	nvlist_t *propval;
	zfs_prop_t prop;
	char buf[ZAP_MAXNAMELEN];
	char *valstr;
	const char *suffix;
	const char *propname;
	const char *source;

	suffix = strchr(za.za_name, '$');

	if (suffix == NULL) {
	/*
	* Skip local properties if we only want received
	* properties.
	*/
	if (flags & DSL_PROP_GET_RECEIVED)
	continue;

	propname = za.za_name;
	source = setpoint;
	} else if (strcmp(suffix, ZPROP_INHERIT_SUFFIX) == 0) {
	/* Skip explicitly inherited entries. */
	continue;
	} else if (strcmp(suffix, ZPROP_RECVD_SUFFIX) == 0) {
	if (flags & DSL_PROP_GET_LOCAL)
	continue;

	(void) strncpy(buf, za.za_name, (suffix - za.za_name));
	buf[suffix - za.za_name] = '\0';
	propname = buf;

	if (!(flags & DSL_PROP_GET_RECEIVED)) {
	/* Skip if locally overridden. */
	err = zap_contains(mos, propobj, propname);
	if (err == 0)
	continue;
	if (err != ENOENT)
	break;

	/* Skip if explicitly inherited. */
	valstr = kmem_asprintf("%s%s", propname,
	ZPROP_INHERIT_SUFFIX);
	err = zap_contains(mos, propobj, valstr);
	kmem_strfree(valstr);
	if (err == 0)
	continue;
	if (err != ENOENT)
	break;
	}

	source = ((flags & DSL_PROP_GET_INHERITING) ?
	setpoint : ZPROP_SOURCE_VAL_RECVD);
	} else {
	/*
	* For backward compatibility, skip suffixes we don't
	* recognize.
	*/
	continue;
	}

	prop = zfs_name_to_prop(propname);

	/* Skip non-inheritable properties. */
	if ((flags & DSL_PROP_GET_INHERITING) && prop != ZPROP_INVAL &&
	!zfs_prop_inheritable(prop))
	continue;

	/* Skip properties not valid for this type. */
	if ((flags & DSL_PROP_GET_SNAPSHOT) && prop != ZPROP_INVAL &&
	!zfs_prop_valid_for_type(prop, ZFS_TYPE_SNAPSHOT, B_FALSE))
	continue;

	/* Skip properties already defined. */
	if (nvlist_exists(nv, propname))
	continue;

	VERIFY(nvlist_alloc(&propval, NV_UNIQUE_NAME, KM_SLEEP) == 0);
	if (za.za_integer_length == 1) {
	/*
	* String property
	*/
	char *tmp = kmem_alloc(za.za_num_integers,
	KM_SLEEP);
	err = zap_lookup(mos, propobj,
	za.za_name, 1, za.za_num_integers, tmp);
	if (err != 0) {
	kmem_free(tmp, za.za_num_integers);
	break;
	}
	VERIFY(nvlist_add_string(propval, ZPROP_VALUE,
	tmp) == 0);
	kmem_free(tmp, za.za_num_integers);
	} else {
	/*
	* Integer property
	*/
	ASSERT(za.za_integer_length == 8);
	(void) nvlist_add_uint64(propval, ZPROP_VALUE,
	za.za_first_integer);
	}

	VERIFY(nvlist_add_string(propval, ZPROP_SOURCE, source) == 0);
	VERIFY(nvlist_add_nvlist(nv, propname, propval) == 0);
	nvlist_free(propval);
	}
	zap_cursor_fini(&zc);
	if (err == ENOENT)
	err = 0;
	return (err);
	}

	/*
	* Iterate over all properties for this dataset and return them in an nvlist.
	*/
	static int
	dsl_prop_get_all_ds(dsl_dataset_t ds, nvlist_t *nvp,
	dsl_prop_getflags_t flags)
	{
	dsl_dir_t *dd = ds->ds_dir;
	dsl_pool_t *dp = dd->dd_pool;
	objset_t *mos = dp->dp_meta_objset;
	int err = 0;
	char setpoint[ZFS_MAX_DATASET_NAME_LEN];

	VERIFY(nvlist_alloc(nvp, NV_UNIQUE_NAME, KM_SLEEP) == 0);

	if (ds->ds_is_snapshot)
	flags \|= DSL_PROP_GET_SNAPSHOT;

	ASSERT(dsl_pool_config_held(dp));

	if (dsl_dataset_phys(ds)->ds_props_obj != 0) {
	ASSERT(flags & DSL_PROP_GET_SNAPSHOT);
	dsl_dataset_name(ds, setpoint);
	err = dsl_prop_get_all_impl(mos,
	dsl_dataset_phys(ds)->ds_props_obj, setpoint, flags, *nvp);
	if (err)
	goto out;
	}

	for (; dd != NULL; dd = dd->dd_parent) {
	if (dd != ds->ds_dir \|\| (flags & DSL_PROP_GET_SNAPSHOT)) {
	if (flags & (DSL_PROP_GET_LOCAL \|
	DSL_PROP_GET_RECEIVED))
	break;
	flags \|= DSL_PROP_GET_INHERITING;
	}
	dsl_dir_name(dd, setpoint);
	err = dsl_prop_get_all_impl(mos,
	dsl_dir_phys(dd)->dd_props_zapobj, setpoint, flags, *nvp);
	if (err)
	break;
	}

	out:
	if (err) {
	nvlist_free(*nvp);
	*nvp = NULL;
	}
	return (err);
	}

	boolean_t
	dsl_prop_get_hasrecvd(const char *dsname)
	{
	uint64_t dummy;

	return (0 ==
	dsl_prop_get_integer(dsname, ZPROP_HAS_RECVD, &dummy, NULL));
	}

	static int
	dsl_prop_set_hasrecvd_impl(const char *dsname, zprop_source_t source)
	{
	uint64_t version;
	spa_t *spa;
	int error = 0;

	VERIFY0(spa_open(dsname, &spa, FTAG));
	version = spa_version(spa);
	spa_close(spa, FTAG);

	if (version >= SPA_VERSION_RECVD_PROPS)
	error = dsl_prop_set_int(dsname, ZPROP_HAS_RECVD, source, 0);
	return (error);
	}

	/*
	* Call after successfully receiving properties to ensure that only the first
	* receive on or after SPA_VERSION_RECVD_PROPS blows away local properties.
	*/
	int
	dsl_prop_set_hasrecvd(const char *dsname)
	{
	int error = 0;
	if (!dsl_prop_get_hasrecvd(dsname))
	error = dsl_prop_set_hasrecvd_impl(dsname, ZPROP_SRC_LOCAL);
	return (error);
	}

	void
	dsl_prop_unset_hasrecvd(const char *dsname)
	{
	VERIFY0(dsl_prop_set_hasrecvd_impl(dsname, ZPROP_SRC_NONE));
	}

	int
	dsl_prop_get_all(objset_t os, nvlist_t *nvp)
	{
	return (dsl_prop_get_all_ds(os->os_dsl_dataset, nvp, 0));
	}

	int
	dsl_prop_get_received(const char dsname, nvlist_t *nvp)
	{
	objset_t *os;
	int error;

	/*
	* Received properties are not distinguishable from local properties
	* until the dataset has received properties on or after
	* SPA_VERSION_RECVD_PROPS.
	*/
	dsl_prop_getflags_t flags = (dsl_prop_get_hasrecvd(dsname) ?
	DSL_PROP_GET_RECEIVED : DSL_PROP_GET_LOCAL);

	error = dmu_objset_hold(dsname, FTAG, &os);
	if (error != 0)
	return (error);
	error = dsl_prop_get_all_ds(os->os_dsl_dataset, nvp, flags);
	dmu_objset_rele(os, FTAG);
	return (error);
	}

	void
	dsl_prop_nvlist_add_uint64(nvlist_t *nv, zfs_prop_t prop, uint64_t value)
	{
	nvlist_t *propval;
	const char *propname = zfs_prop_to_name(prop);
	uint64_t default_value;

	if (nvlist_lookup_nvlist(nv, propname, &propval) == 0) {
	VERIFY(nvlist_add_uint64(propval, ZPROP_VALUE, value) == 0);
	return;
	}

	VERIFY(nvlist_alloc(&propval, NV_UNIQUE_NAME, KM_SLEEP) == 0);
	VERIFY(nvlist_add_uint64(propval, ZPROP_VALUE, value) == 0);
	/* Indicate the default source if we can. */
	if (dodefault(prop, 8, 1, &default_value) == 0 &&
	value == default_value) {
	VERIFY(nvlist_add_string(propval, ZPROP_SOURCE, "") == 0);
	}
	VERIFY(nvlist_add_nvlist(nv, propname, propval) == 0);
	nvlist_free(propval);
	}

	void
	dsl_prop_nvlist_add_string(nvlist_t nv, zfs_prop_t prop, const char value)
	{
	nvlist_t *propval;
	const char *propname = zfs_prop_to_name(prop);

	if (nvlist_lookup_nvlist(nv, propname, &propval) == 0) {
	VERIFY(nvlist_add_string(propval, ZPROP_VALUE, value) == 0);
	return;
	}

	VERIFY(nvlist_alloc(&propval, NV_UNIQUE_NAME, KM_SLEEP) == 0);
	VERIFY(nvlist_add_string(propval, ZPROP_VALUE, value) == 0);
	VERIFY(nvlist_add_nvlist(nv, propname, propval) == 0);
	nvlist_free(propval);
	}

	#if defined(_KERNEL)
	EXPORT_SYMBOL(dsl_prop_register);
	EXPORT_SYMBOL(dsl_prop_unregister);
	EXPORT_SYMBOL(dsl_prop_unregister_all);
	EXPORT_SYMBOL(dsl_prop_get);
	EXPORT_SYMBOL(dsl_prop_get_integer);
	EXPORT_SYMBOL(dsl_prop_get_all);
	EXPORT_SYMBOL(dsl_prop_get_received);
	EXPORT_SYMBOL(dsl_prop_get_ds);
	EXPORT_SYMBOL(dsl_prop_get_int_ds);
	EXPORT_SYMBOL(dsl_prop_get_dd);
	EXPORT_SYMBOL(dsl_props_set);
	EXPORT_SYMBOL(dsl_prop_set_int);
	EXPORT_SYMBOL(dsl_prop_set_string);
	EXPORT_SYMBOL(dsl_prop_inherit);
	EXPORT_SYMBOL(dsl_prop_predict);
	EXPORT_SYMBOL(dsl_prop_nvlist_add_uint64);
	EXPORT_SYMBOL(dsl_prop_nvlist_add_string);
	#endif
	diff --git a/sys/contrib/openzfs/module/zfs/spa.c b/sys/contrib/openzfs/module/zfs/spa.c
	index 55870bee47fb..a02fd198bed0 100644
	--- a/sys/contrib/openzfs/module/zfs/spa.c
	+++ b/sys/contrib/openzfs/module/zfs/spa.c
	@@ -1,9951 +1,9951 @@
	/*
	* 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. 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_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 = 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 cpus, flags = TASKQ_DYNAMIC;
	boolean_t batch = B_FALSE;

	switch (mode) {
	case ZTI_MODE_FIXED:
	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];

	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, %lld remaining",
	(u_longlong_t)dle->dle_bpobj.bpo_object,
	(u_longlong_t)ll_obj, (longlong_t)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",
	(u_longlong_t)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,
	minclsyspri);
	}

	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)", (u_longlong_t)tx->tx_txg, dsname,
	(u_longlong_t)ds->ds_object, (u_longlong_t)first_obj,
	(u_longlong_t)cur_first_size, (u_longlong_t)next_obj,
	(u_longlong_t)cur_next_size,
	(u_longlong_t)first->dle_bpobj.bpo_object,
	(u_longlong_t)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, minclsyspri);
	}

	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, minclsyspri);
	}

	/*
	* 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=%llu", (u_longlong_t)import_delay,
	(u_longlong_t)MMP_FAIL_INT(ub),
	(u_longlong_t)MMP_INTERVAL(ub),
	(u_longlong_t)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=%llu", (u_longlong_t)import_delay,
	(u_longlong_t)MMP_INTERVAL(ub),
	(u_longlong_t)ub->ub_mmp_delay,
	(u_longlong_t)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=%llu leaves=%u",
	(u_longlong_t)import_delay,
	(u_longlong_t)ub->ub_mmp_delay,
	(u_longlong_t)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=%llu", (u_longlong_t)import_delay,
	(u_longlong_t)multihost_interval,
	(u_longlong_t)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 * random_in_range(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",
	(u_longlong_t)txg, (u_longlong_t)ub->ub_txg,
	(u_longlong_t)timestamp,
	(u_longlong_t)ub->ub_timestamp,
	(u_longlong_t)mmp_config,
	(u_longlong_t)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 = 0;

	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 = random_in_range(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 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. We also need to
	* update the cache file to keep it in sync with the
	* MOS version. 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_async_request(spa, SPA_ASYNC_CONFIG_UPDATE);
	}
	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_async_request(spa, SPA_ASYNC_CONFIG_UPDATE);
	}

	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 = random_in_range(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_allocs[i].spaa_lock);
	VERIFY0(avl_numnodes(&spa->spa_allocs[i].spaa_tree));
	mutex_exit(&spa->spa_allocs[i].spaa_lock);
	}

	/*
	* 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_allocs[i].spaa_lock);
	VERIFY0(avl_numnodes(&spa->spa_allocs[i].spaa_tree));
	mutex_exit(&spa->spa_allocs[i].spaa_lock);
	}

	/*
	* 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 */
	+ fallthrough;
	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 "
	"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/vdev.c b/sys/contrib/openzfs/module/zfs/vdev.c
	index 4e316d8135ee..d659ec5bf333 100644
	--- a/sys/contrib/openzfs/module/zfs/vdev.c
	+++ b/sys/contrib/openzfs/module/zfs/vdev.c
	@@ -1,5426 +1,5450 @@
	/*
	* 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 %llu: %s", indent, "",
	(u_longlong_t)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 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 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 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_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)
	{
	+ char old, new;
	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);
	}
	+
	+ /*
	+ * Our enclosure sysfs path may have changed between imports
	+ */
	+ old = dvd->vdev_enc_sysfs_path;
	+ new = svd->vdev_enc_sysfs_path;
	+ if ((old != NULL && new == NULL) \|\|
	+ (old == NULL && new != NULL) \|\|
	+ ((old != NULL && new != NULL) && strcmp(new, old) != 0)) {
	+ zfs_dbgmsg("vdev_copy_path: vdev %llu: vdev_enc_sysfs_path "
	+ "changed from '%s' to '%s'", (u_longlong_t)dvd->vdev_guid,
	+ old, new);
	+
	+ if (dvd->vdev_enc_sysfs_path)
	+ spa_strfree(dvd->vdev_enc_sysfs_path);
	+
	+ if (svd->vdev_enc_sysfs_path) {
	+ dvd->vdev_enc_sysfs_path = spa_strdup(
	+ svd->vdev_enc_sysfs_path);
	+ } else {
	+ dvd->vdev_enc_sysfs_path = NULL;
	+ }
	+ }
	}

	/*
	* 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 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 %lu 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_label.c b/sys/contrib/openzfs/module/zfs/vdev_label.c
	index 04202a9f8960..ec6bbc6fc610 100644
	--- a/sys/contrib/openzfs/module/zfs/vdev_label.c
	+++ b/sys/contrib/openzfs/module/zfs/vdev_label.c
	@@ -1,1992 +1,1992 @@
	/*
	* 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) 2017, Intel Corporation.
	*/

	/*
	* Virtual Device Labels
	* ---------------------
	*
	* The vdev label serves several distinct purposes:
	*
	* 1. Uniquely identify this device as part of a ZFS pool and confirm its
	* identity within the pool.
	*
	* 2. Verify that all the devices given in a configuration are present
	* within the pool.
	*
	* 3. Determine the uberblock for the pool.
	*
	* 4. In case of an import operation, determine the configuration of the
	* toplevel vdev of which it is a part.
	*
	* 5. If an import operation cannot find all the devices in the pool,
	* provide enough information to the administrator to determine which
	* devices are missing.
	*
	* It is important to note that while the kernel is responsible for writing the
	* label, it only consumes the information in the first three cases. The
	* latter information is only consumed in userland when determining the
	* configuration to import a pool.
	*
	*
	* Label Organization
	* ------------------
	*
	* Before describing the contents of the label, it's important to understand how
	* the labels are written and updated with respect to the uberblock.
	*
	* When the pool configuration is altered, either because it was newly created
	* or a device was added, we want to update all the labels such that we can deal
	* with fatal failure at any point. To this end, each disk has two labels which
	* are updated before and after the uberblock is synced. Assuming we have
	* labels and an uberblock with the following transaction groups:
	*
	* L1 UB L2
	* +------+ +------+ +------+
	* \| \| \| \| \| \|
	* \| t10 \| \| t10 \| \| t10 \|
	* \| \| \| \| \| \|
	* +------+ +------+ +------+
	*
	* In this stable state, the labels and the uberblock were all updated within
	* the same transaction group (10). Each label is mirrored and checksummed, so
	* that we can detect when we fail partway through writing the label.
	*
	* In order to identify which labels are valid, the labels are written in the
	* following manner:
	*
	* 1. For each vdev, update 'L1' to the new label
	* 2. Update the uberblock
	* 3. For each vdev, update 'L2' to the new label
	*
	* Given arbitrary failure, we can determine the correct label to use based on
	* the transaction group. If we fail after updating L1 but before updating the
	* UB, we will notice that L1's transaction group is greater than the uberblock,
	* so L2 must be valid. If we fail after writing the uberblock but before
	* writing L2, we will notice that L2's transaction group is less than L1, and
	* therefore L1 is valid.
	*
	* Another added complexity is that not every label is updated when the config
	* is synced. If we add a single device, we do not want to have to re-write
	* every label for every device in the pool. This means that both L1 and L2 may
	* be older than the pool uberblock, because the necessary information is stored
	* on another vdev.
	*
	*
	* On-disk Format
	* --------------
	*
	* The vdev label consists of two distinct parts, and is wrapped within the
	* vdev_label_t structure. The label includes 8k of padding to permit legacy
	* VTOC disk labels, but is otherwise ignored.
	*
	* The first half of the label is a packed nvlist which contains pool wide
	* properties, per-vdev properties, and configuration information. It is
	* described in more detail below.
	*
	* The latter half of the label consists of a redundant array of uberblocks.
	* These uberblocks are updated whenever a transaction group is committed,
	* or when the configuration is updated. When a pool is loaded, we scan each
	* vdev for the 'best' uberblock.
	*
	*
	* Configuration Information
	* -------------------------
	*
	* The nvlist describing the pool and vdev contains the following elements:
	*
	* version ZFS on-disk version
	* name Pool name
	* state Pool state
	* txg Transaction group in which this label was written
	* pool_guid Unique identifier for this pool
	* vdev_tree An nvlist describing vdev tree.
	* features_for_read
	* An nvlist of the features necessary for reading the MOS.
	*
	* Each leaf device label also contains the following:
	*
	* top_guid Unique ID for top-level vdev in which this is contained
	* guid Unique ID for the leaf vdev
	*
	* The 'vs' configuration follows the format described in 'spa_config.c'.
	*/

	#include <sys/zfs_context.h>
	#include <sys/spa.h>
	#include <sys/spa_impl.h>
	#include <sys/dmu.h>
	#include <sys/zap.h>
	#include <sys/vdev.h>
	#include <sys/vdev_impl.h>
	#include <sys/vdev_draid.h>
	#include <sys/uberblock_impl.h>
	#include <sys/metaslab.h>
	#include <sys/metaslab_impl.h>
	#include <sys/zio.h>
	#include <sys/dsl_scan.h>
	#include <sys/abd.h>
	#include <sys/fs/zfs.h>
	#include <sys/byteorder.h>
	#include <sys/zfs_bootenv.h>

	/*
	* Basic routines to read and write from a vdev label.
	* Used throughout the rest of this file.
	*/
	uint64_t
	vdev_label_offset(uint64_t psize, int l, uint64_t offset)
	{
	ASSERT(offset < sizeof (vdev_label_t));
	ASSERT(P2PHASE_TYPED(psize, sizeof (vdev_label_t), uint64_t) == 0);

	return (offset + l * sizeof (vdev_label_t) + (l < VDEV_LABELS / 2 ?
	0 : psize - VDEV_LABELS * sizeof (vdev_label_t)));
	}

	/*
	* Returns back the vdev label associated with the passed in offset.
	*/
	int
	vdev_label_number(uint64_t psize, uint64_t offset)
	{
	int l;

	if (offset >= psize - VDEV_LABEL_END_SIZE) {
	offset -= psize - VDEV_LABEL_END_SIZE;
	offset += (VDEV_LABELS / 2) * sizeof (vdev_label_t);
	}
	l = offset / sizeof (vdev_label_t);
	return (l < VDEV_LABELS ? l : -1);
	}

	static void
	vdev_label_read(zio_t zio, vdev_t vd, int l, abd_t *buf, uint64_t offset,
	uint64_t size, zio_done_func_t done, void private, int flags)
	{
	ASSERT(
	spa_config_held(zio->io_spa, SCL_STATE, RW_READER) == SCL_STATE \|\|
	spa_config_held(zio->io_spa, SCL_STATE, RW_WRITER) == SCL_STATE);
	ASSERT(flags & ZIO_FLAG_CONFIG_WRITER);

	zio_nowait(zio_read_phys(zio, vd,
	vdev_label_offset(vd->vdev_psize, l, offset),
	size, buf, ZIO_CHECKSUM_LABEL, done, private,
	ZIO_PRIORITY_SYNC_READ, flags, B_TRUE));
	}

	void
	vdev_label_write(zio_t zio, vdev_t vd, int l, abd_t *buf, uint64_t offset,
	uint64_t size, zio_done_func_t done, void private, int flags)
	{
	ASSERT(
	spa_config_held(zio->io_spa, SCL_STATE, RW_READER) == SCL_STATE \|\|
	spa_config_held(zio->io_spa, SCL_STATE, RW_WRITER) == SCL_STATE);
	ASSERT(flags & ZIO_FLAG_CONFIG_WRITER);

	zio_nowait(zio_write_phys(zio, vd,
	vdev_label_offset(vd->vdev_psize, l, offset),
	size, buf, ZIO_CHECKSUM_LABEL, done, private,
	ZIO_PRIORITY_SYNC_WRITE, flags, B_TRUE));
	}

	/*
	* Generate the nvlist representing this vdev's stats
	*/
	void
	vdev_config_generate_stats(vdev_t vd, nvlist_t nv)
	{
	nvlist_t *nvx;
	vdev_stat_t *vs;
	vdev_stat_ex_t *vsx;

	vs = kmem_alloc(sizeof (*vs), KM_SLEEP);
	vsx = kmem_alloc(sizeof (*vsx), KM_SLEEP);

	vdev_get_stats_ex(vd, vs, vsx);
	fnvlist_add_uint64_array(nv, ZPOOL_CONFIG_VDEV_STATS,
	(uint64_t )vs, sizeof (vs) / sizeof (uint64_t));

	/*
	* Add extended stats into a special extended stats nvlist. This keeps
	* all the extended stats nicely grouped together. The extended stats
	* nvlist is then added to the main nvlist.
	*/
	nvx = fnvlist_alloc();

	/* ZIOs in flight to disk */
	fnvlist_add_uint64(nvx, ZPOOL_CONFIG_VDEV_SYNC_R_ACTIVE_QUEUE,
	vsx->vsx_active_queue[ZIO_PRIORITY_SYNC_READ]);

	fnvlist_add_uint64(nvx, ZPOOL_CONFIG_VDEV_SYNC_W_ACTIVE_QUEUE,
	vsx->vsx_active_queue[ZIO_PRIORITY_SYNC_WRITE]);

	fnvlist_add_uint64(nvx, ZPOOL_CONFIG_VDEV_ASYNC_R_ACTIVE_QUEUE,
	vsx->vsx_active_queue[ZIO_PRIORITY_ASYNC_READ]);

	fnvlist_add_uint64(nvx, ZPOOL_CONFIG_VDEV_ASYNC_W_ACTIVE_QUEUE,
	vsx->vsx_active_queue[ZIO_PRIORITY_ASYNC_WRITE]);

	fnvlist_add_uint64(nvx, ZPOOL_CONFIG_VDEV_SCRUB_ACTIVE_QUEUE,
	vsx->vsx_active_queue[ZIO_PRIORITY_SCRUB]);

	fnvlist_add_uint64(nvx, ZPOOL_CONFIG_VDEV_TRIM_ACTIVE_QUEUE,
	vsx->vsx_active_queue[ZIO_PRIORITY_TRIM]);

	/* ZIOs pending */
	fnvlist_add_uint64(nvx, ZPOOL_CONFIG_VDEV_SYNC_R_PEND_QUEUE,
	vsx->vsx_pend_queue[ZIO_PRIORITY_SYNC_READ]);

	fnvlist_add_uint64(nvx, ZPOOL_CONFIG_VDEV_SYNC_W_PEND_QUEUE,
	vsx->vsx_pend_queue[ZIO_PRIORITY_SYNC_WRITE]);

	fnvlist_add_uint64(nvx, ZPOOL_CONFIG_VDEV_ASYNC_R_PEND_QUEUE,
	vsx->vsx_pend_queue[ZIO_PRIORITY_ASYNC_READ]);

	fnvlist_add_uint64(nvx, ZPOOL_CONFIG_VDEV_ASYNC_W_PEND_QUEUE,
	vsx->vsx_pend_queue[ZIO_PRIORITY_ASYNC_WRITE]);

	fnvlist_add_uint64(nvx, ZPOOL_CONFIG_VDEV_SCRUB_PEND_QUEUE,
	vsx->vsx_pend_queue[ZIO_PRIORITY_SCRUB]);

	fnvlist_add_uint64(nvx, ZPOOL_CONFIG_VDEV_TRIM_PEND_QUEUE,
	vsx->vsx_pend_queue[ZIO_PRIORITY_TRIM]);

	/* Histograms */
	fnvlist_add_uint64_array(nvx, ZPOOL_CONFIG_VDEV_TOT_R_LAT_HISTO,
	vsx->vsx_total_histo[ZIO_TYPE_READ],
	ARRAY_SIZE(vsx->vsx_total_histo[ZIO_TYPE_READ]));

	fnvlist_add_uint64_array(nvx, ZPOOL_CONFIG_VDEV_TOT_W_LAT_HISTO,
	vsx->vsx_total_histo[ZIO_TYPE_WRITE],
	ARRAY_SIZE(vsx->vsx_total_histo[ZIO_TYPE_WRITE]));

	fnvlist_add_uint64_array(nvx, ZPOOL_CONFIG_VDEV_DISK_R_LAT_HISTO,
	vsx->vsx_disk_histo[ZIO_TYPE_READ],
	ARRAY_SIZE(vsx->vsx_disk_histo[ZIO_TYPE_READ]));

	fnvlist_add_uint64_array(nvx, ZPOOL_CONFIG_VDEV_DISK_W_LAT_HISTO,
	vsx->vsx_disk_histo[ZIO_TYPE_WRITE],
	ARRAY_SIZE(vsx->vsx_disk_histo[ZIO_TYPE_WRITE]));

	fnvlist_add_uint64_array(nvx, ZPOOL_CONFIG_VDEV_SYNC_R_LAT_HISTO,
	vsx->vsx_queue_histo[ZIO_PRIORITY_SYNC_READ],
	ARRAY_SIZE(vsx->vsx_queue_histo[ZIO_PRIORITY_SYNC_READ]));

	fnvlist_add_uint64_array(nvx, ZPOOL_CONFIG_VDEV_SYNC_W_LAT_HISTO,
	vsx->vsx_queue_histo[ZIO_PRIORITY_SYNC_WRITE],
	ARRAY_SIZE(vsx->vsx_queue_histo[ZIO_PRIORITY_SYNC_WRITE]));

	fnvlist_add_uint64_array(nvx, ZPOOL_CONFIG_VDEV_ASYNC_R_LAT_HISTO,
	vsx->vsx_queue_histo[ZIO_PRIORITY_ASYNC_READ],
	ARRAY_SIZE(vsx->vsx_queue_histo[ZIO_PRIORITY_ASYNC_READ]));

	fnvlist_add_uint64_array(nvx, ZPOOL_CONFIG_VDEV_ASYNC_W_LAT_HISTO,
	vsx->vsx_queue_histo[ZIO_PRIORITY_ASYNC_WRITE],
	ARRAY_SIZE(vsx->vsx_queue_histo[ZIO_PRIORITY_ASYNC_WRITE]));

	fnvlist_add_uint64_array(nvx, ZPOOL_CONFIG_VDEV_SCRUB_LAT_HISTO,
	vsx->vsx_queue_histo[ZIO_PRIORITY_SCRUB],
	ARRAY_SIZE(vsx->vsx_queue_histo[ZIO_PRIORITY_SCRUB]));

	fnvlist_add_uint64_array(nvx, ZPOOL_CONFIG_VDEV_TRIM_LAT_HISTO,
	vsx->vsx_queue_histo[ZIO_PRIORITY_TRIM],
	ARRAY_SIZE(vsx->vsx_queue_histo[ZIO_PRIORITY_TRIM]));

	/* Request sizes */
	fnvlist_add_uint64_array(nvx, ZPOOL_CONFIG_VDEV_SYNC_IND_R_HISTO,
	vsx->vsx_ind_histo[ZIO_PRIORITY_SYNC_READ],
	ARRAY_SIZE(vsx->vsx_ind_histo[ZIO_PRIORITY_SYNC_READ]));

	fnvlist_add_uint64_array(nvx, ZPOOL_CONFIG_VDEV_SYNC_IND_W_HISTO,
	vsx->vsx_ind_histo[ZIO_PRIORITY_SYNC_WRITE],
	ARRAY_SIZE(vsx->vsx_ind_histo[ZIO_PRIORITY_SYNC_WRITE]));

	fnvlist_add_uint64_array(nvx, ZPOOL_CONFIG_VDEV_ASYNC_IND_R_HISTO,
	vsx->vsx_ind_histo[ZIO_PRIORITY_ASYNC_READ],
	ARRAY_SIZE(vsx->vsx_ind_histo[ZIO_PRIORITY_ASYNC_READ]));

	fnvlist_add_uint64_array(nvx, ZPOOL_CONFIG_VDEV_ASYNC_IND_W_HISTO,
	vsx->vsx_ind_histo[ZIO_PRIORITY_ASYNC_WRITE],
	ARRAY_SIZE(vsx->vsx_ind_histo[ZIO_PRIORITY_ASYNC_WRITE]));

	fnvlist_add_uint64_array(nvx, ZPOOL_CONFIG_VDEV_IND_SCRUB_HISTO,
	vsx->vsx_ind_histo[ZIO_PRIORITY_SCRUB],
	ARRAY_SIZE(vsx->vsx_ind_histo[ZIO_PRIORITY_SCRUB]));

	fnvlist_add_uint64_array(nvx, ZPOOL_CONFIG_VDEV_IND_TRIM_HISTO,
	vsx->vsx_ind_histo[ZIO_PRIORITY_TRIM],
	ARRAY_SIZE(vsx->vsx_ind_histo[ZIO_PRIORITY_TRIM]));

	fnvlist_add_uint64_array(nvx, ZPOOL_CONFIG_VDEV_SYNC_AGG_R_HISTO,
	vsx->vsx_agg_histo[ZIO_PRIORITY_SYNC_READ],
	ARRAY_SIZE(vsx->vsx_agg_histo[ZIO_PRIORITY_SYNC_READ]));

	fnvlist_add_uint64_array(nvx, ZPOOL_CONFIG_VDEV_SYNC_AGG_W_HISTO,
	vsx->vsx_agg_histo[ZIO_PRIORITY_SYNC_WRITE],
	ARRAY_SIZE(vsx->vsx_agg_histo[ZIO_PRIORITY_SYNC_WRITE]));

	fnvlist_add_uint64_array(nvx, ZPOOL_CONFIG_VDEV_ASYNC_AGG_R_HISTO,
	vsx->vsx_agg_histo[ZIO_PRIORITY_ASYNC_READ],
	ARRAY_SIZE(vsx->vsx_agg_histo[ZIO_PRIORITY_ASYNC_READ]));

	fnvlist_add_uint64_array(nvx, ZPOOL_CONFIG_VDEV_ASYNC_AGG_W_HISTO,
	vsx->vsx_agg_histo[ZIO_PRIORITY_ASYNC_WRITE],
	ARRAY_SIZE(vsx->vsx_agg_histo[ZIO_PRIORITY_ASYNC_WRITE]));

	fnvlist_add_uint64_array(nvx, ZPOOL_CONFIG_VDEV_AGG_SCRUB_HISTO,
	vsx->vsx_agg_histo[ZIO_PRIORITY_SCRUB],
	ARRAY_SIZE(vsx->vsx_agg_histo[ZIO_PRIORITY_SCRUB]));

	fnvlist_add_uint64_array(nvx, ZPOOL_CONFIG_VDEV_AGG_TRIM_HISTO,
	vsx->vsx_agg_histo[ZIO_PRIORITY_TRIM],
	ARRAY_SIZE(vsx->vsx_agg_histo[ZIO_PRIORITY_TRIM]));

	/* IO delays */
	fnvlist_add_uint64(nvx, ZPOOL_CONFIG_VDEV_SLOW_IOS, vs->vs_slow_ios);

	/* Add extended stats nvlist to main nvlist */
	fnvlist_add_nvlist(nv, ZPOOL_CONFIG_VDEV_STATS_EX, nvx);

	fnvlist_free(nvx);
	kmem_free(vs, sizeof (*vs));
	kmem_free(vsx, sizeof (*vsx));
	}

	static void
	root_vdev_actions_getprogress(vdev_t vd, nvlist_t nvl)
	{
	spa_t *spa = vd->vdev_spa;

	if (vd != spa->spa_root_vdev)
	return;

	/* provide either current or previous scan information */
	pool_scan_stat_t ps;
	if (spa_scan_get_stats(spa, &ps) == 0) {
	fnvlist_add_uint64_array(nvl,
	ZPOOL_CONFIG_SCAN_STATS, (uint64_t *)&ps,
	sizeof (pool_scan_stat_t) / sizeof (uint64_t));
	}

	pool_removal_stat_t prs;
	if (spa_removal_get_stats(spa, &prs) == 0) {
	fnvlist_add_uint64_array(nvl,
	ZPOOL_CONFIG_REMOVAL_STATS, (uint64_t *)&prs,
	sizeof (prs) / sizeof (uint64_t));
	}

	pool_checkpoint_stat_t pcs;
	if (spa_checkpoint_get_stats(spa, &pcs) == 0) {
	fnvlist_add_uint64_array(nvl,
	ZPOOL_CONFIG_CHECKPOINT_STATS, (uint64_t *)&pcs,
	sizeof (pcs) / sizeof (uint64_t));
	}
	}

	static void
	top_vdev_actions_getprogress(vdev_t vd, nvlist_t nvl)
	{
	if (vd == vd->vdev_top) {
	vdev_rebuild_stat_t vrs;
	if (vdev_rebuild_get_stats(vd, &vrs) == 0) {
	fnvlist_add_uint64_array(nvl,
	ZPOOL_CONFIG_REBUILD_STATS, (uint64_t *)&vrs,
	sizeof (vrs) / sizeof (uint64_t));
	}
	}
	}

	/*
	* Generate the nvlist representing this vdev's config.
	*/
	nvlist_t *
	vdev_config_generate(spa_t spa, vdev_t vd, boolean_t getstats,
	vdev_config_flag_t flags)
	{
	nvlist_t *nv = NULL;
	vdev_indirect_config_t *vic = &vd->vdev_indirect_config;

	nv = fnvlist_alloc();

	fnvlist_add_string(nv, ZPOOL_CONFIG_TYPE, vd->vdev_ops->vdev_op_type);
	if (!(flags & (VDEV_CONFIG_SPARE \| VDEV_CONFIG_L2CACHE)))
	fnvlist_add_uint64(nv, ZPOOL_CONFIG_ID, vd->vdev_id);
	fnvlist_add_uint64(nv, ZPOOL_CONFIG_GUID, vd->vdev_guid);

	if (vd->vdev_path != NULL)
	fnvlist_add_string(nv, ZPOOL_CONFIG_PATH, vd->vdev_path);

	if (vd->vdev_devid != NULL)
	fnvlist_add_string(nv, ZPOOL_CONFIG_DEVID, vd->vdev_devid);

	if (vd->vdev_physpath != NULL)
	fnvlist_add_string(nv, ZPOOL_CONFIG_PHYS_PATH,
	vd->vdev_physpath);

	if (vd->vdev_enc_sysfs_path != NULL)
	fnvlist_add_string(nv, ZPOOL_CONFIG_VDEV_ENC_SYSFS_PATH,
	vd->vdev_enc_sysfs_path);

	if (vd->vdev_fru != NULL)
	fnvlist_add_string(nv, ZPOOL_CONFIG_FRU, vd->vdev_fru);

	if (vd->vdev_ops->vdev_op_config_generate != NULL)
	vd->vdev_ops->vdev_op_config_generate(vd, nv);

	if (vd->vdev_wholedisk != -1ULL) {
	fnvlist_add_uint64(nv, ZPOOL_CONFIG_WHOLE_DISK,
	vd->vdev_wholedisk);
	}

	if (vd->vdev_not_present && !(flags & VDEV_CONFIG_MISSING))
	fnvlist_add_uint64(nv, ZPOOL_CONFIG_NOT_PRESENT, 1);

	if (vd->vdev_isspare)
	fnvlist_add_uint64(nv, ZPOOL_CONFIG_IS_SPARE, 1);

	if (!(flags & (VDEV_CONFIG_SPARE \| VDEV_CONFIG_L2CACHE)) &&
	vd == vd->vdev_top) {
	fnvlist_add_uint64(nv, ZPOOL_CONFIG_METASLAB_ARRAY,
	vd->vdev_ms_array);
	fnvlist_add_uint64(nv, ZPOOL_CONFIG_METASLAB_SHIFT,
	vd->vdev_ms_shift);
	fnvlist_add_uint64(nv, ZPOOL_CONFIG_ASHIFT, vd->vdev_ashift);
	fnvlist_add_uint64(nv, ZPOOL_CONFIG_ASIZE,
	vd->vdev_asize);
	fnvlist_add_uint64(nv, ZPOOL_CONFIG_IS_LOG, vd->vdev_islog);
	if (vd->vdev_removing) {
	fnvlist_add_uint64(nv, ZPOOL_CONFIG_REMOVING,
	vd->vdev_removing);
	}

	/* zpool command expects alloc class data */
	if (getstats && vd->vdev_alloc_bias != VDEV_BIAS_NONE) {
	const char *bias = NULL;

	switch (vd->vdev_alloc_bias) {
	case VDEV_BIAS_LOG:
	bias = VDEV_ALLOC_BIAS_LOG;
	break;
	case VDEV_BIAS_SPECIAL:
	bias = VDEV_ALLOC_BIAS_SPECIAL;
	break;
	case VDEV_BIAS_DEDUP:
	bias = VDEV_ALLOC_BIAS_DEDUP;
	break;
	default:
	ASSERT3U(vd->vdev_alloc_bias, ==,
	VDEV_BIAS_NONE);
	}
	fnvlist_add_string(nv, ZPOOL_CONFIG_ALLOCATION_BIAS,
	bias);
	}
	}

	if (vd->vdev_dtl_sm != NULL) {
	fnvlist_add_uint64(nv, ZPOOL_CONFIG_DTL,
	space_map_object(vd->vdev_dtl_sm));
	}

	if (vic->vic_mapping_object != 0) {
	fnvlist_add_uint64(nv, ZPOOL_CONFIG_INDIRECT_OBJECT,
	vic->vic_mapping_object);
	}

	if (vic->vic_births_object != 0) {
	fnvlist_add_uint64(nv, ZPOOL_CONFIG_INDIRECT_BIRTHS,
	vic->vic_births_object);
	}

	if (vic->vic_prev_indirect_vdev != UINT64_MAX) {
	fnvlist_add_uint64(nv, ZPOOL_CONFIG_PREV_INDIRECT_VDEV,
	vic->vic_prev_indirect_vdev);
	}

	if (vd->vdev_crtxg)
	fnvlist_add_uint64(nv, ZPOOL_CONFIG_CREATE_TXG, vd->vdev_crtxg);

	if (vd->vdev_expansion_time)
	fnvlist_add_uint64(nv, ZPOOL_CONFIG_EXPANSION_TIME,
	vd->vdev_expansion_time);

	if (flags & VDEV_CONFIG_MOS) {
	if (vd->vdev_leaf_zap != 0) {
	ASSERT(vd->vdev_ops->vdev_op_leaf);
	fnvlist_add_uint64(nv, ZPOOL_CONFIG_VDEV_LEAF_ZAP,
	vd->vdev_leaf_zap);
	}

	if (vd->vdev_top_zap != 0) {
	ASSERT(vd == vd->vdev_top);
	fnvlist_add_uint64(nv, ZPOOL_CONFIG_VDEV_TOP_ZAP,
	vd->vdev_top_zap);
	}

	if (vd->vdev_resilver_deferred) {
	ASSERT(vd->vdev_ops->vdev_op_leaf);
	ASSERT(spa->spa_resilver_deferred);
	fnvlist_add_boolean(nv, ZPOOL_CONFIG_RESILVER_DEFER);
	}
	}

	if (getstats) {
	vdev_config_generate_stats(vd, nv);

	root_vdev_actions_getprogress(vd, nv);
	top_vdev_actions_getprogress(vd, nv);

	/*
	* Note: this can be called from open context
	* (spa_get_stats()), so we need the rwlock to prevent
	* the mapping from being changed by condensing.
	*/
	rw_enter(&vd->vdev_indirect_rwlock, RW_READER);
	if (vd->vdev_indirect_mapping != NULL) {
	ASSERT(vd->vdev_indirect_births != NULL);
	vdev_indirect_mapping_t *vim =
	vd->vdev_indirect_mapping;
	fnvlist_add_uint64(nv, ZPOOL_CONFIG_INDIRECT_SIZE,
	vdev_indirect_mapping_size(vim));
	}
	rw_exit(&vd->vdev_indirect_rwlock);
	if (vd->vdev_mg != NULL &&
	vd->vdev_mg->mg_fragmentation != ZFS_FRAG_INVALID) {
	/*
	* Compute approximately how much memory would be used
	* for the indirect mapping if this device were to
	* be removed.
	*
	* Note: If the frag metric is invalid, then not
	* enough metaslabs have been converted to have
	* histograms.
	*/
	uint64_t seg_count = 0;
	uint64_t to_alloc = vd->vdev_stat.vs_alloc;

	/*
	* There are the same number of allocated segments
	* as free segments, so we will have at least one
	* entry per free segment. However, small free
	* segments (smaller than vdev_removal_max_span)
	* will be combined with adjacent allocated segments
	* as a single mapping.
	*/
	for (int i = 0; i < RANGE_TREE_HISTOGRAM_SIZE; i++) {
	if (i + 1 < highbit64(vdev_removal_max_span)
	- 1) {
	to_alloc +=
	vd->vdev_mg->mg_histogram[i] <<
	(i + 1);
	} else {
	seg_count +=
	vd->vdev_mg->mg_histogram[i];
	}
	}

	/*
	* The maximum length of a mapping is
	* zfs_remove_max_segment, so we need at least one entry
	* per zfs_remove_max_segment of allocated data.
	*/
	seg_count += to_alloc / spa_remove_max_segment(spa);

	fnvlist_add_uint64(nv, ZPOOL_CONFIG_INDIRECT_SIZE,
	seg_count *
	sizeof (vdev_indirect_mapping_entry_phys_t));
	}
	}

	if (!vd->vdev_ops->vdev_op_leaf) {
	nvlist_t **child;
	int c, idx;

	ASSERT(!vd->vdev_ishole);

	child = kmem_alloc(vd->vdev_children * sizeof (nvlist_t *),
	KM_SLEEP);

	for (c = 0, idx = 0; c < vd->vdev_children; c++) {
	vdev_t *cvd = vd->vdev_child[c];

	/*
	* If we're generating an nvlist of removing
	* vdevs then skip over any device which is
	* not being removed.
	*/
	if ((flags & VDEV_CONFIG_REMOVING) &&
	!cvd->vdev_removing)
	continue;

	child[idx++] = vdev_config_generate(spa, cvd,
	getstats, flags);
	}

	if (idx) {
	fnvlist_add_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN,
	child, idx);
	}

	for (c = 0; c < idx; c++)
	nvlist_free(child[c]);

	kmem_free(child, vd->vdev_children * sizeof (nvlist_t *));

	} else {
	const char *aux = NULL;

	if (vd->vdev_offline && !vd->vdev_tmpoffline)
	fnvlist_add_uint64(nv, ZPOOL_CONFIG_OFFLINE, B_TRUE);
	if (vd->vdev_resilver_txg != 0)
	fnvlist_add_uint64(nv, ZPOOL_CONFIG_RESILVER_TXG,
	vd->vdev_resilver_txg);
	if (vd->vdev_rebuild_txg != 0)
	fnvlist_add_uint64(nv, ZPOOL_CONFIG_REBUILD_TXG,
	vd->vdev_rebuild_txg);
	if (vd->vdev_faulted)
	fnvlist_add_uint64(nv, ZPOOL_CONFIG_FAULTED, B_TRUE);
	if (vd->vdev_degraded)
	fnvlist_add_uint64(nv, ZPOOL_CONFIG_DEGRADED, B_TRUE);
	if (vd->vdev_removed)
	fnvlist_add_uint64(nv, ZPOOL_CONFIG_REMOVED, B_TRUE);
	if (vd->vdev_unspare)
	fnvlist_add_uint64(nv, ZPOOL_CONFIG_UNSPARE, B_TRUE);
	if (vd->vdev_ishole)
	fnvlist_add_uint64(nv, ZPOOL_CONFIG_IS_HOLE, B_TRUE);

	/* Set the reason why we're FAULTED/DEGRADED. */
	switch (vd->vdev_stat.vs_aux) {
	case VDEV_AUX_ERR_EXCEEDED:
	aux = "err_exceeded";
	break;

	case VDEV_AUX_EXTERNAL:
	aux = "external";
	break;
	}

	if (aux != NULL && !vd->vdev_tmpoffline) {
	fnvlist_add_string(nv, ZPOOL_CONFIG_AUX_STATE, aux);
	} else {
	/*
	* We're healthy - clear any previous AUX_STATE values.
	*/
	if (nvlist_exists(nv, ZPOOL_CONFIG_AUX_STATE))
	nvlist_remove_all(nv, ZPOOL_CONFIG_AUX_STATE);
	}

	if (vd->vdev_splitting && vd->vdev_orig_guid != 0LL) {
	fnvlist_add_uint64(nv, ZPOOL_CONFIG_ORIG_GUID,
	vd->vdev_orig_guid);
	}
	}

	return (nv);
	}

	/*
	* Generate a view of the top-level vdevs. If we currently have holes
	* in the namespace, then generate an array which contains a list of holey
	* vdevs. Additionally, add the number of top-level children that currently
	* exist.
	*/
	void
	vdev_top_config_generate(spa_t spa, nvlist_t config)
	{
	vdev_t *rvd = spa->spa_root_vdev;
	uint64_t *array;
	uint_t c, idx;

	array = kmem_alloc(rvd->vdev_children * sizeof (uint64_t), KM_SLEEP);

	for (c = 0, idx = 0; c < rvd->vdev_children; c++) {
	vdev_t *tvd = rvd->vdev_child[c];

	if (tvd->vdev_ishole) {
	array[idx++] = c;
	}
	}

	if (idx) {
	VERIFY(nvlist_add_uint64_array(config, ZPOOL_CONFIG_HOLE_ARRAY,
	array, idx) == 0);
	}

	VERIFY(nvlist_add_uint64(config, ZPOOL_CONFIG_VDEV_CHILDREN,
	rvd->vdev_children) == 0);

	kmem_free(array, rvd->vdev_children * sizeof (uint64_t));
	}

	/*
	* Returns the configuration from the label of the given vdev. For vdevs
	* which don't have a txg value stored on their label (i.e. spares/cache)
	* or have not been completely initialized (txg = 0) just return
	* the configuration from the first valid label we find. Otherwise,
	* find the most up-to-date label that does not exceed the specified
	* 'txg' value.
	*/
	nvlist_t *
	vdev_label_read_config(vdev_t *vd, uint64_t txg)
	{
	spa_t *spa = vd->vdev_spa;
	nvlist_t *config = NULL;
	vdev_phys_t *vp[VDEV_LABELS];
	abd_t *vp_abd[VDEV_LABELS];
	zio_t *zio[VDEV_LABELS];
	uint64_t best_txg = 0;
	uint64_t label_txg = 0;
	int error = 0;
	int flags = ZIO_FLAG_CONFIG_WRITER \| ZIO_FLAG_CANFAIL \|
	ZIO_FLAG_SPECULATIVE;

	ASSERT(vd->vdev_validate_thread == curthread \|\|
	spa_config_held(spa, SCL_STATE_ALL, RW_WRITER) == SCL_STATE_ALL);

	if (!vdev_readable(vd))
	return (NULL);

	/*
	* The label for a dRAID distributed spare is not stored on disk.
	* Instead it is generated when needed which allows us to bypass
	* the pipeline when reading the config from the label.
	*/
	if (vd->vdev_ops == &vdev_draid_spare_ops)
	return (vdev_draid_read_config_spare(vd));

	for (int l = 0; l < VDEV_LABELS; l++) {
	vp_abd[l] = abd_alloc_linear(sizeof (vdev_phys_t), B_TRUE);
	vp[l] = abd_to_buf(vp_abd[l]);
	}

	retry:
	for (int l = 0; l < VDEV_LABELS; l++) {
	zio[l] = zio_root(spa, NULL, NULL, flags);

	vdev_label_read(zio[l], vd, l, vp_abd[l],
	offsetof(vdev_label_t, vl_vdev_phys), sizeof (vdev_phys_t),
	NULL, NULL, flags);
	}
	for (int l = 0; l < VDEV_LABELS; l++) {
	nvlist_t *label = NULL;

	if (zio_wait(zio[l]) == 0 &&
	nvlist_unpack(vp[l]->vp_nvlist, sizeof (vp[l]->vp_nvlist),
	&label, 0) == 0) {
	/*
	* Auxiliary vdevs won't have txg values in their
	* labels and newly added vdevs may not have been
	* completely initialized so just return the
	* configuration from the first valid label we
	* encounter.
	*/
	error = nvlist_lookup_uint64(label,
	ZPOOL_CONFIG_POOL_TXG, &label_txg);
	if ((error \|\| label_txg == 0) && !config) {
	config = label;
	for (l++; l < VDEV_LABELS; l++)
	zio_wait(zio[l]);
	break;
	} else if (label_txg <= txg && label_txg > best_txg) {
	best_txg = label_txg;
	nvlist_free(config);
	config = fnvlist_dup(label);
	}
	}

	if (label != NULL) {
	nvlist_free(label);
	label = NULL;
	}
	}

	if (config == NULL && !(flags & ZIO_FLAG_TRYHARD)) {
	flags \|= ZIO_FLAG_TRYHARD;
	goto retry;
	}

	/*
	* We found a valid label but it didn't pass txg restrictions.
	*/
	if (config == NULL && label_txg != 0) {
	vdev_dbgmsg(vd, "label discarded as txg is too large "
	"(%llu > %llu)", (u_longlong_t)label_txg,
	(u_longlong_t)txg);
	}

	for (int l = 0; l < VDEV_LABELS; l++) {
	abd_free(vp_abd[l]);
	}

	return (config);
	}

	/*
	* Determine if a device is in use. The 'spare_guid' parameter will be filled
	* in with the device guid if this spare is active elsewhere on the system.
	*/
	static boolean_t
	vdev_inuse(vdev_t *vd, uint64_t crtxg, vdev_labeltype_t reason,
	uint64_t spare_guid, uint64_t l2cache_guid)
	{
	spa_t *spa = vd->vdev_spa;
	uint64_t state, pool_guid, device_guid, txg, spare_pool;
	uint64_t vdtxg = 0;
	nvlist_t *label;

	if (spare_guid)
	*spare_guid = 0ULL;
	if (l2cache_guid)
	*l2cache_guid = 0ULL;

	/*
	* Read the label, if any, and perform some basic sanity checks.
	*/
	if ((label = vdev_label_read_config(vd, -1ULL)) == NULL)
	return (B_FALSE);

	(void) nvlist_lookup_uint64(label, ZPOOL_CONFIG_CREATE_TXG,
	&vdtxg);

	if (nvlist_lookup_uint64(label, ZPOOL_CONFIG_POOL_STATE,
	&state) != 0 \|\|
	nvlist_lookup_uint64(label, ZPOOL_CONFIG_GUID,
	&device_guid) != 0) {
	nvlist_free(label);
	return (B_FALSE);
	}

	if (state != POOL_STATE_SPARE && state != POOL_STATE_L2CACHE &&
	(nvlist_lookup_uint64(label, ZPOOL_CONFIG_POOL_GUID,
	&pool_guid) != 0 \|\|
	nvlist_lookup_uint64(label, ZPOOL_CONFIG_POOL_TXG,
	&txg) != 0)) {
	nvlist_free(label);
	return (B_FALSE);
	}

	nvlist_free(label);

	/*
	* Check to see if this device indeed belongs to the pool it claims to
	* be a part of. The only way this is allowed is if the device is a hot
	* spare (which we check for later on).
	*/
	if (state != POOL_STATE_SPARE && state != POOL_STATE_L2CACHE &&
	!spa_guid_exists(pool_guid, device_guid) &&
	!spa_spare_exists(device_guid, NULL, NULL) &&
	!spa_l2cache_exists(device_guid, NULL))
	return (B_FALSE);

	/*
	* If the transaction group is zero, then this an initialized (but
	* unused) label. This is only an error if the create transaction
	* on-disk is the same as the one we're using now, in which case the
	* user has attempted to add the same vdev multiple times in the same
	* transaction.
	*/
	if (state != POOL_STATE_SPARE && state != POOL_STATE_L2CACHE &&
	txg == 0 && vdtxg == crtxg)
	return (B_TRUE);

	/*
	* Check to see if this is a spare device. We do an explicit check for
	* spa_has_spare() here because it may be on our pending list of spares
	* to add. We also check if it is an l2cache device.
	*/
	if (spa_spare_exists(device_guid, &spare_pool, NULL) \|\|
	spa_has_spare(spa, device_guid)) {
	if (spare_guid)
	*spare_guid = device_guid;

	switch (reason) {
	case VDEV_LABEL_CREATE:
	case VDEV_LABEL_L2CACHE:
	return (B_TRUE);

	case VDEV_LABEL_REPLACE:
	return (!spa_has_spare(spa, device_guid) \|\|
	spare_pool != 0ULL);

	case VDEV_LABEL_SPARE:
	return (spa_has_spare(spa, device_guid));
	default:
	break;
	}
	}

	/*
	* Check to see if this is an l2cache device.
	*/
	if (spa_l2cache_exists(device_guid, NULL))
	return (B_TRUE);

	/*
	* We can't rely on a pool's state if it's been imported
	* read-only. Instead we look to see if the pools is marked
	* read-only in the namespace and set the state to active.
	*/
	if (state != POOL_STATE_SPARE && state != POOL_STATE_L2CACHE &&
	(spa = spa_by_guid(pool_guid, device_guid)) != NULL &&
	spa_mode(spa) == SPA_MODE_READ)
	state = POOL_STATE_ACTIVE;

	/*
	* If the device is marked ACTIVE, then this device is in use by another
	* pool on the system.
	*/
	return (state == POOL_STATE_ACTIVE);
	}

	/*
	* Initialize a vdev label. We check to make sure each leaf device is not in
	* use, and writable. We put down an initial label which we will later
	* overwrite with a complete label. Note that it's important to do this
	* sequentially, not in parallel, so that we catch cases of multiple use of the
	* same leaf vdev in the vdev we're creating -- e.g. mirroring a disk with
	* itself.
	*/
	int
	vdev_label_init(vdev_t *vd, uint64_t crtxg, vdev_labeltype_t reason)
	{
	spa_t *spa = vd->vdev_spa;
	nvlist_t *label;
	vdev_phys_t *vp;
	abd_t *vp_abd;
	abd_t *bootenv;
	uberblock_t *ub;
	abd_t *ub_abd;
	zio_t *zio;
	char *buf;
	size_t buflen;
	int error;
	uint64_t spare_guid = 0, l2cache_guid = 0;
	int flags = ZIO_FLAG_CONFIG_WRITER \| ZIO_FLAG_CANFAIL;

	ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == SCL_ALL);

	for (int c = 0; c < vd->vdev_children; c++)
	if ((error = vdev_label_init(vd->vdev_child[c],
	crtxg, reason)) != 0)
	return (error);

	/* Track the creation time for this vdev */
	vd->vdev_crtxg = crtxg;

	if (!vd->vdev_ops->vdev_op_leaf \|\| !spa_writeable(spa))
	return (0);

	/*
	* Dead vdevs cannot be initialized.
	*/
	if (vdev_is_dead(vd))
	return (SET_ERROR(EIO));

	/*
	* Determine if the vdev is in use.
	*/
	if (reason != VDEV_LABEL_REMOVE && reason != VDEV_LABEL_SPLIT &&
	vdev_inuse(vd, crtxg, reason, &spare_guid, &l2cache_guid))
	return (SET_ERROR(EBUSY));

	/*
	* If this is a request to add or replace a spare or l2cache device
	* that is in use elsewhere on the system, then we must update the
	* guid (which was initialized to a random value) to reflect the
	* actual GUID (which is shared between multiple pools).
	*/
	if (reason != VDEV_LABEL_REMOVE && reason != VDEV_LABEL_L2CACHE &&
	spare_guid != 0ULL) {
	uint64_t guid_delta = spare_guid - vd->vdev_guid;

	vd->vdev_guid += guid_delta;

	for (vdev_t *pvd = vd; pvd != NULL; pvd = pvd->vdev_parent)
	pvd->vdev_guid_sum += guid_delta;

	/*
	* If this is a replacement, then we want to fallthrough to the
	* rest of the code. If we're adding a spare, then it's already
	* labeled appropriately and we can just return.
	*/
	if (reason == VDEV_LABEL_SPARE)
	return (0);
	ASSERT(reason == VDEV_LABEL_REPLACE \|\|
	reason == VDEV_LABEL_SPLIT);
	}

	if (reason != VDEV_LABEL_REMOVE && reason != VDEV_LABEL_SPARE &&
	l2cache_guid != 0ULL) {
	uint64_t guid_delta = l2cache_guid - vd->vdev_guid;

	vd->vdev_guid += guid_delta;

	for (vdev_t *pvd = vd; pvd != NULL; pvd = pvd->vdev_parent)
	pvd->vdev_guid_sum += guid_delta;

	/*
	* If this is a replacement, then we want to fallthrough to the
	* rest of the code. If we're adding an l2cache, then it's
	* already labeled appropriately and we can just return.
	*/
	if (reason == VDEV_LABEL_L2CACHE)
	return (0);
	ASSERT(reason == VDEV_LABEL_REPLACE);
	}

	/*
	* Initialize its label.
	*/
	vp_abd = abd_alloc_linear(sizeof (vdev_phys_t), B_TRUE);
	abd_zero(vp_abd, sizeof (vdev_phys_t));
	vp = abd_to_buf(vp_abd);

	/*
	* Generate a label describing the pool and our top-level vdev.
	* We mark it as being from txg 0 to indicate that it's not
	* really part of an active pool just yet. The labels will
	* be written again with a meaningful txg by spa_sync().
	*/
	if (reason == VDEV_LABEL_SPARE \|\|
	(reason == VDEV_LABEL_REMOVE && vd->vdev_isspare)) {
	/*
	* For inactive hot spares, we generate a special label that
	* identifies as a mutually shared hot spare. We write the
	* label if we are adding a hot spare, or if we are removing an
	* active hot spare (in which case we want to revert the
	* labels).
	*/
	VERIFY(nvlist_alloc(&label, NV_UNIQUE_NAME, KM_SLEEP) == 0);

	VERIFY(nvlist_add_uint64(label, ZPOOL_CONFIG_VERSION,
	spa_version(spa)) == 0);
	VERIFY(nvlist_add_uint64(label, ZPOOL_CONFIG_POOL_STATE,
	POOL_STATE_SPARE) == 0);
	VERIFY(nvlist_add_uint64(label, ZPOOL_CONFIG_GUID,
	vd->vdev_guid) == 0);
	} else if (reason == VDEV_LABEL_L2CACHE \|\|
	(reason == VDEV_LABEL_REMOVE && vd->vdev_isl2cache)) {
	/*
	* For level 2 ARC devices, add a special label.
	*/
	VERIFY(nvlist_alloc(&label, NV_UNIQUE_NAME, KM_SLEEP) == 0);

	VERIFY(nvlist_add_uint64(label, ZPOOL_CONFIG_VERSION,
	spa_version(spa)) == 0);
	VERIFY(nvlist_add_uint64(label, ZPOOL_CONFIG_POOL_STATE,
	POOL_STATE_L2CACHE) == 0);
	VERIFY(nvlist_add_uint64(label, ZPOOL_CONFIG_GUID,
	vd->vdev_guid) == 0);
	} else {
	uint64_t txg = 0ULL;

	if (reason == VDEV_LABEL_SPLIT)
	txg = spa->spa_uberblock.ub_txg;
	label = spa_config_generate(spa, vd, txg, B_FALSE);

	/*
	* Add our creation time. This allows us to detect multiple
	* vdev uses as described above, and automatically expires if we
	* fail.
	*/
	VERIFY(nvlist_add_uint64(label, ZPOOL_CONFIG_CREATE_TXG,
	crtxg) == 0);
	}

	buf = vp->vp_nvlist;
	buflen = sizeof (vp->vp_nvlist);

	error = nvlist_pack(label, &buf, &buflen, NV_ENCODE_XDR, KM_SLEEP);
	if (error != 0) {
	nvlist_free(label);
	abd_free(vp_abd);
	/* EFAULT means nvlist_pack ran out of room */
	return (SET_ERROR(error == EFAULT ? ENAMETOOLONG : EINVAL));
	}

	/*
	* Initialize uberblock template.
	*/
	ub_abd = abd_alloc_linear(VDEV_UBERBLOCK_RING, B_TRUE);
	abd_zero(ub_abd, VDEV_UBERBLOCK_RING);
	abd_copy_from_buf(ub_abd, &spa->spa_uberblock, sizeof (uberblock_t));
	ub = abd_to_buf(ub_abd);
	ub->ub_txg = 0;

	/* Initialize the 2nd padding area. */
	bootenv = abd_alloc_for_io(VDEV_PAD_SIZE, B_TRUE);
	abd_zero(bootenv, VDEV_PAD_SIZE);

	/*
	* Write everything in parallel.
	*/
	retry:
	zio = zio_root(spa, NULL, NULL, flags);

	for (int l = 0; l < VDEV_LABELS; l++) {

	vdev_label_write(zio, vd, l, vp_abd,
	offsetof(vdev_label_t, vl_vdev_phys),
	sizeof (vdev_phys_t), NULL, NULL, flags);

	/*
	* Skip the 1st padding area.
	* Zero out the 2nd padding area where it might have
	* left over data from previous filesystem format.
	*/
	vdev_label_write(zio, vd, l, bootenv,
	offsetof(vdev_label_t, vl_be),
	VDEV_PAD_SIZE, NULL, NULL, flags);

	vdev_label_write(zio, vd, l, ub_abd,
	offsetof(vdev_label_t, vl_uberblock),
	VDEV_UBERBLOCK_RING, NULL, NULL, flags);
	}

	error = zio_wait(zio);

	if (error != 0 && !(flags & ZIO_FLAG_TRYHARD)) {
	flags \|= ZIO_FLAG_TRYHARD;
	goto retry;
	}

	nvlist_free(label);
	abd_free(bootenv);
	abd_free(ub_abd);
	abd_free(vp_abd);

	/*
	* If this vdev hasn't been previously identified as a spare, then we
	* mark it as such only if a) we are labeling it as a spare, or b) it
	* exists as a spare elsewhere in the system. Do the same for
	* level 2 ARC devices.
	*/
	if (error == 0 && !vd->vdev_isspare &&
	(reason == VDEV_LABEL_SPARE \|\|
	spa_spare_exists(vd->vdev_guid, NULL, NULL)))
	spa_spare_add(vd);

	if (error == 0 && !vd->vdev_isl2cache &&
	(reason == VDEV_LABEL_L2CACHE \|\|
	spa_l2cache_exists(vd->vdev_guid, NULL)))
	spa_l2cache_add(vd);

	return (error);
	}

	/*
	* Done callback for vdev_label_read_bootenv_impl. If this is the first
	* callback to finish, store our abd in the callback pointer. Otherwise, we
	* just free our abd and return.
	*/
	static void
	vdev_label_read_bootenv_done(zio_t *zio)
	{
	zio_t *rio = zio->io_private;
	abd_t **cbp = rio->io_private;

	ASSERT3U(zio->io_size, ==, VDEV_PAD_SIZE);

	if (zio->io_error == 0) {
	mutex_enter(&rio->io_lock);
	if (*cbp == NULL) {
	/* Will free this buffer in vdev_label_read_bootenv. */
	*cbp = zio->io_abd;
	} else {
	abd_free(zio->io_abd);
	}
	mutex_exit(&rio->io_lock);
	} else {
	abd_free(zio->io_abd);
	}
	}

	static void
	vdev_label_read_bootenv_impl(zio_t zio, vdev_t vd, int flags)
	{
	for (int c = 0; c < vd->vdev_children; c++)
	vdev_label_read_bootenv_impl(zio, vd->vdev_child[c], flags);

	/*
	* We just use the first label that has a correct checksum; the
	* bootloader should have rewritten them all to be the same on boot,
	* and any changes we made since boot have been the same across all
	* labels.
	*/
	if (vd->vdev_ops->vdev_op_leaf && vdev_readable(vd)) {
	for (int l = 0; l < VDEV_LABELS; l++) {
	vdev_label_read(zio, vd, l,
	abd_alloc_linear(VDEV_PAD_SIZE, B_FALSE),
	offsetof(vdev_label_t, vl_be), VDEV_PAD_SIZE,
	vdev_label_read_bootenv_done, zio, flags);
	}
	}
	}

	int
	vdev_label_read_bootenv(vdev_t rvd, nvlist_t bootenv)
	{
	nvlist_t *config;
	spa_t *spa = rvd->vdev_spa;
	abd_t *abd = NULL;
	int flags = ZIO_FLAG_CONFIG_WRITER \| ZIO_FLAG_CANFAIL \|
	ZIO_FLAG_SPECULATIVE \| ZIO_FLAG_TRYHARD;

	ASSERT(bootenv);
	ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == SCL_ALL);

	zio_t *zio = zio_root(spa, NULL, &abd, flags);
	vdev_label_read_bootenv_impl(zio, rvd, flags);
	int err = zio_wait(zio);

	if (abd != NULL) {
	char *buf;
	vdev_boot_envblock_t *vbe = abd_to_buf(abd);

	vbe->vbe_version = ntohll(vbe->vbe_version);
	switch (vbe->vbe_version) {
	case VB_RAW:
	/*
	* if we have textual data in vbe_bootenv, create nvlist
	* with key "envmap".
	*/
	fnvlist_add_uint64(bootenv, BOOTENV_VERSION, VB_RAW);
	vbe->vbe_bootenv[sizeof (vbe->vbe_bootenv) - 1] = '\0';
	fnvlist_add_string(bootenv, GRUB_ENVMAP,
	vbe->vbe_bootenv);
	break;

	case VB_NVLIST:
	err = nvlist_unpack(vbe->vbe_bootenv,
	sizeof (vbe->vbe_bootenv), &config, 0);
	if (err == 0) {
	fnvlist_merge(bootenv, config);
	nvlist_free(config);
	break;
	}
	- /* FALLTHROUGH */
	+ fallthrough;
	default:
	/* Check for FreeBSD zfs bootonce command string */
	buf = abd_to_buf(abd);
	if (*buf == '\0') {
	fnvlist_add_uint64(bootenv, BOOTENV_VERSION,
	VB_NVLIST);
	break;
	}
	fnvlist_add_string(bootenv, FREEBSD_BOOTONCE, buf);
	}

	/*
	* abd was allocated in vdev_label_read_bootenv_impl()
	*/
	abd_free(abd);
	/*
	* If we managed to read any successfully,
	* return success.
	*/
	return (0);
	}
	return (err);
	}

	int
	vdev_label_write_bootenv(vdev_t vd, nvlist_t env)
	{
	zio_t *zio;
	spa_t *spa = vd->vdev_spa;
	vdev_boot_envblock_t *bootenv;
	int flags = ZIO_FLAG_CONFIG_WRITER \| ZIO_FLAG_CANFAIL;
	int error;
	size_t nvsize;
	char *nvbuf;

	error = nvlist_size(env, &nvsize, NV_ENCODE_XDR);
	if (error != 0)
	return (SET_ERROR(error));

	if (nvsize >= sizeof (bootenv->vbe_bootenv)) {
	return (SET_ERROR(E2BIG));
	}

	ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == SCL_ALL);

	error = ENXIO;
	for (int c = 0; c < vd->vdev_children; c++) {
	int child_err;

	child_err = vdev_label_write_bootenv(vd->vdev_child[c], env);
	/*
	* As long as any of the disks managed to write all of their
	* labels successfully, return success.
	*/
	if (child_err == 0)
	error = child_err;
	}

	if (!vd->vdev_ops->vdev_op_leaf \|\| vdev_is_dead(vd) \|\|
	!vdev_writeable(vd)) {
	return (error);
	}
	ASSERT3U(sizeof (*bootenv), ==, VDEV_PAD_SIZE);
	abd_t *abd = abd_alloc_for_io(VDEV_PAD_SIZE, B_TRUE);
	abd_zero(abd, VDEV_PAD_SIZE);

	bootenv = abd_borrow_buf_copy(abd, VDEV_PAD_SIZE);
	nvbuf = bootenv->vbe_bootenv;
	nvsize = sizeof (bootenv->vbe_bootenv);

	bootenv->vbe_version = fnvlist_lookup_uint64(env, BOOTENV_VERSION);
	switch (bootenv->vbe_version) {
	case VB_RAW:
	if (nvlist_lookup_string(env, GRUB_ENVMAP, &nvbuf) == 0) {
	(void) strlcpy(bootenv->vbe_bootenv, nvbuf, nvsize);
	}
	error = 0;
	break;

	case VB_NVLIST:
	error = nvlist_pack(env, &nvbuf, &nvsize, NV_ENCODE_XDR,
	KM_SLEEP);
	break;

	default:
	error = EINVAL;
	break;
	}

	if (error == 0) {
	bootenv->vbe_version = htonll(bootenv->vbe_version);
	abd_return_buf_copy(abd, bootenv, VDEV_PAD_SIZE);
	} else {
	abd_free(abd);
	return (SET_ERROR(error));
	}

	retry:
	zio = zio_root(spa, NULL, NULL, flags);
	for (int l = 0; l < VDEV_LABELS; l++) {
	vdev_label_write(zio, vd, l, abd,
	offsetof(vdev_label_t, vl_be),
	VDEV_PAD_SIZE, NULL, NULL, flags);
	}

	error = zio_wait(zio);
	if (error != 0 && !(flags & ZIO_FLAG_TRYHARD)) {
	flags \|= ZIO_FLAG_TRYHARD;
	goto retry;
	}

	abd_free(abd);
	return (error);
	}

	/*
	* ==========================================================================
	* uberblock load/sync
	* ==========================================================================
	*/

	/*
	* Consider the following situation: txg is safely synced to disk. We've
	* written the first uberblock for txg + 1, and then we lose power. When we
	* come back up, we fail to see the uberblock for txg + 1 because, say,
	* it was on a mirrored device and the replica to which we wrote txg + 1
	* is now offline. If we then make some changes and sync txg + 1, and then
	* the missing replica comes back, then for a few seconds we'll have two
	* conflicting uberblocks on disk with the same txg. The solution is simple:
	* among uberblocks with equal txg, choose the one with the latest timestamp.
	*/
	static int
	vdev_uberblock_compare(const uberblock_t ub1, const uberblock_t ub2)
	{
	int cmp = TREE_CMP(ub1->ub_txg, ub2->ub_txg);

	if (likely(cmp))
	return (cmp);

	cmp = TREE_CMP(ub1->ub_timestamp, ub2->ub_timestamp);
	if (likely(cmp))
	return (cmp);

	/*
	* If MMP_VALID(ub) && MMP_SEQ_VALID(ub) then the host has an MMP-aware
	* ZFS, e.g. OpenZFS >= 0.7.
	*
	* If one ub has MMP and the other does not, they were written by
	* different hosts, which matters for MMP. So we treat no MMP/no SEQ as
	* a 0 value.
	*
	* Since timestamp and txg are the same if we get this far, either is
	* acceptable for importing the pool.
	*/
	unsigned int seq1 = 0;
	unsigned int seq2 = 0;

	if (MMP_VALID(ub1) && MMP_SEQ_VALID(ub1))
	seq1 = MMP_SEQ(ub1);

	if (MMP_VALID(ub2) && MMP_SEQ_VALID(ub2))
	seq2 = MMP_SEQ(ub2);

	return (TREE_CMP(seq1, seq2));
	}

	struct ubl_cbdata {
	uberblock_t ubl_ubbest; / Best uberblock */
	vdev_t ubl_vd; / vdev associated with the above */
	};

	static void
	vdev_uberblock_load_done(zio_t *zio)
	{
	vdev_t *vd = zio->io_vd;
	spa_t *spa = zio->io_spa;
	zio_t *rio = zio->io_private;
	uberblock_t *ub = abd_to_buf(zio->io_abd);
	struct ubl_cbdata *cbp = rio->io_private;

	ASSERT3U(zio->io_size, ==, VDEV_UBERBLOCK_SIZE(vd));

	if (zio->io_error == 0 && uberblock_verify(ub) == 0) {
	mutex_enter(&rio->io_lock);
	if (ub->ub_txg <= spa->spa_load_max_txg &&
	vdev_uberblock_compare(ub, cbp->ubl_ubbest) > 0) {
	/*
	* Keep track of the vdev in which this uberblock
	* was found. We will use this information later
	* to obtain the config nvlist associated with
	* this uberblock.
	*/
	cbp->ubl_ubbest = ub;
	cbp->ubl_vd = vd;
	}
	mutex_exit(&rio->io_lock);
	}

	abd_free(zio->io_abd);
	}

	static void
	vdev_uberblock_load_impl(zio_t zio, vdev_t vd, int flags,
	struct ubl_cbdata *cbp)
	{
	for (int c = 0; c < vd->vdev_children; c++)
	vdev_uberblock_load_impl(zio, vd->vdev_child[c], flags, cbp);

	if (vd->vdev_ops->vdev_op_leaf && vdev_readable(vd) &&
	vd->vdev_ops != &vdev_draid_spare_ops) {
	for (int l = 0; l < VDEV_LABELS; l++) {
	for (int n = 0; n < VDEV_UBERBLOCK_COUNT(vd); n++) {
	vdev_label_read(zio, vd, l,
	abd_alloc_linear(VDEV_UBERBLOCK_SIZE(vd),
	B_TRUE), VDEV_UBERBLOCK_OFFSET(vd, n),
	VDEV_UBERBLOCK_SIZE(vd),
	vdev_uberblock_load_done, zio, flags);
	}
	}
	}
	}

	/*
	* Reads the 'best' uberblock from disk along with its associated
	* configuration. First, we read the uberblock array of each label of each
	* vdev, keeping track of the uberblock with the highest txg in each array.
	* Then, we read the configuration from the same vdev as the best uberblock.
	*/
	void
	vdev_uberblock_load(vdev_t rvd, uberblock_t ub, nvlist_t **config)
	{
	zio_t *zio;
	spa_t *spa = rvd->vdev_spa;
	struct ubl_cbdata cb;
	int flags = ZIO_FLAG_CONFIG_WRITER \| ZIO_FLAG_CANFAIL \|
	ZIO_FLAG_SPECULATIVE \| ZIO_FLAG_TRYHARD;

	ASSERT(ub);
	ASSERT(config);

	bzero(ub, sizeof (uberblock_t));
	*config = NULL;

	cb.ubl_ubbest = ub;
	cb.ubl_vd = NULL;

	spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
	zio = zio_root(spa, NULL, &cb, flags);
	vdev_uberblock_load_impl(zio, rvd, flags, &cb);
	(void) zio_wait(zio);

	/*
	* It's possible that the best uberblock was discovered on a label
	* that has a configuration which was written in a future txg.
	* Search all labels on this vdev to find the configuration that
	* matches the txg for our uberblock.
	*/
	if (cb.ubl_vd != NULL) {
	vdev_dbgmsg(cb.ubl_vd, "best uberblock found for spa %s. "
	"txg %llu", spa->spa_name, (u_longlong_t)ub->ub_txg);

	*config = vdev_label_read_config(cb.ubl_vd, ub->ub_txg);
	if (*config == NULL && spa->spa_extreme_rewind) {
	vdev_dbgmsg(cb.ubl_vd, "failed to read label config. "
	"Trying again without txg restrictions.");
	*config = vdev_label_read_config(cb.ubl_vd, UINT64_MAX);
	}
	if (*config == NULL) {
	vdev_dbgmsg(cb.ubl_vd, "failed to read label config");
	}
	}
	spa_config_exit(spa, SCL_ALL, FTAG);
	}

	/*
	* For use when a leaf vdev is expanded.
	* The location of labels 2 and 3 changed, and at the new location the
	* uberblock rings are either empty or contain garbage. The sync will write
	* new configs there because the vdev is dirty, but expansion also needs the
	* uberblock rings copied. Read them from label 0 which did not move.
	*
	* Since the point is to populate labels {2,3} with valid uberblocks,
	* we zero uberblocks we fail to read or which are not valid.
	*/

	static void
	vdev_copy_uberblocks(vdev_t *vd)
	{
	abd_t *ub_abd;
	zio_t *write_zio;
	int locks = (SCL_L2ARC \| SCL_ZIO);
	int flags = ZIO_FLAG_CONFIG_WRITER \| ZIO_FLAG_CANFAIL \|
	ZIO_FLAG_SPECULATIVE;

	ASSERT(spa_config_held(vd->vdev_spa, SCL_STATE, RW_READER) ==
	SCL_STATE);
	ASSERT(vd->vdev_ops->vdev_op_leaf);

	/*
	* No uberblocks are stored on distributed spares, they may be
	* safely skipped when expanding a leaf vdev.
	*/
	if (vd->vdev_ops == &vdev_draid_spare_ops)
	return;

	spa_config_enter(vd->vdev_spa, locks, FTAG, RW_READER);

	ub_abd = abd_alloc_linear(VDEV_UBERBLOCK_SIZE(vd), B_TRUE);

	write_zio = zio_root(vd->vdev_spa, NULL, NULL, flags);
	for (int n = 0; n < VDEV_UBERBLOCK_COUNT(vd); n++) {
	const int src_label = 0;
	zio_t *zio;

	zio = zio_root(vd->vdev_spa, NULL, NULL, flags);
	vdev_label_read(zio, vd, src_label, ub_abd,
	VDEV_UBERBLOCK_OFFSET(vd, n), VDEV_UBERBLOCK_SIZE(vd),
	NULL, NULL, flags);

	if (zio_wait(zio) \|\| uberblock_verify(abd_to_buf(ub_abd)))
	abd_zero(ub_abd, VDEV_UBERBLOCK_SIZE(vd));

	for (int l = 2; l < VDEV_LABELS; l++)
	vdev_label_write(write_zio, vd, l, ub_abd,
	VDEV_UBERBLOCK_OFFSET(vd, n),
	VDEV_UBERBLOCK_SIZE(vd), NULL, NULL,
	flags \| ZIO_FLAG_DONT_PROPAGATE);
	}
	(void) zio_wait(write_zio);

	spa_config_exit(vd->vdev_spa, locks, FTAG);

	abd_free(ub_abd);
	}

	/*
	* On success, increment root zio's count of good writes.
	* We only get credit for writes to known-visible vdevs; see spa_vdev_add().
	*/
	static void
	vdev_uberblock_sync_done(zio_t *zio)
	{
	uint64_t *good_writes = zio->io_private;

	if (zio->io_error == 0 && zio->io_vd->vdev_top->vdev_ms_array != 0)
	atomic_inc_64(good_writes);
	}

	/*
	* Write the uberblock to all labels of all leaves of the specified vdev.
	*/
	static void
	vdev_uberblock_sync(zio_t zio, uint64_t good_writes,
	uberblock_t ub, vdev_t vd, int flags)
	{
	for (uint64_t c = 0; c < vd->vdev_children; c++) {
	vdev_uberblock_sync(zio, good_writes,
	ub, vd->vdev_child[c], flags);
	}

	if (!vd->vdev_ops->vdev_op_leaf)
	return;

	if (!vdev_writeable(vd))
	return;

	/*
	* There's no need to write uberblocks to a distributed spare, they
	* are already stored on all the leaves of the parent dRAID. For
	* this same reason vdev_uberblock_load_impl() skips distributed
	* spares when reading uberblocks.
	*/
	if (vd->vdev_ops == &vdev_draid_spare_ops)
	return;

	/* If the vdev was expanded, need to copy uberblock rings. */
	if (vd->vdev_state == VDEV_STATE_HEALTHY &&
	vd->vdev_copy_uberblocks == B_TRUE) {
	vdev_copy_uberblocks(vd);
	vd->vdev_copy_uberblocks = B_FALSE;
	}

	int m = spa_multihost(vd->vdev_spa) ? MMP_BLOCKS_PER_LABEL : 0;
	int n = ub->ub_txg % (VDEV_UBERBLOCK_COUNT(vd) - m);

	/* Copy the uberblock_t into the ABD */
	abd_t *ub_abd = abd_alloc_for_io(VDEV_UBERBLOCK_SIZE(vd), B_TRUE);
	abd_zero(ub_abd, VDEV_UBERBLOCK_SIZE(vd));
	abd_copy_from_buf(ub_abd, ub, sizeof (uberblock_t));

	for (int l = 0; l < VDEV_LABELS; l++)
	vdev_label_write(zio, vd, l, ub_abd,
	VDEV_UBERBLOCK_OFFSET(vd, n), VDEV_UBERBLOCK_SIZE(vd),
	vdev_uberblock_sync_done, good_writes,
	flags \| ZIO_FLAG_DONT_PROPAGATE);

	abd_free(ub_abd);
	}

	/* Sync the uberblocks to all vdevs in svd[] */
	static int
	vdev_uberblock_sync_list(vdev_t *svd, int svdcount, uberblock_t ub, int flags)
	{
	spa_t *spa = svd[0]->vdev_spa;
	zio_t *zio;
	uint64_t good_writes = 0;

	zio = zio_root(spa, NULL, NULL, flags);

	for (int v = 0; v < svdcount; v++)
	vdev_uberblock_sync(zio, &good_writes, ub, svd[v], flags);

	(void) zio_wait(zio);

	/*
	* Flush the uberblocks to disk. This ensures that the odd labels
	* are no longer needed (because the new uberblocks and the even
	* labels are safely on disk), so it is safe to overwrite them.
	*/
	zio = zio_root(spa, NULL, NULL, flags);

	for (int v = 0; v < svdcount; v++) {
	if (vdev_writeable(svd[v])) {
	zio_flush(zio, svd[v]);
	}
	}

	(void) zio_wait(zio);

	return (good_writes >= 1 ? 0 : EIO);
	}

	/*
	* On success, increment the count of good writes for our top-level vdev.
	*/
	static void
	vdev_label_sync_done(zio_t *zio)
	{
	uint64_t *good_writes = zio->io_private;

	if (zio->io_error == 0)
	atomic_inc_64(good_writes);
	}

	/*
	* If there weren't enough good writes, indicate failure to the parent.
	*/
	static void
	vdev_label_sync_top_done(zio_t *zio)
	{
	uint64_t *good_writes = zio->io_private;

	if (*good_writes == 0)
	zio->io_error = SET_ERROR(EIO);

	kmem_free(good_writes, sizeof (uint64_t));
	}

	/*
	* We ignore errors for log and cache devices, simply free the private data.
	*/
	static void
	vdev_label_sync_ignore_done(zio_t *zio)
	{
	kmem_free(zio->io_private, sizeof (uint64_t));
	}

	/*
	* Write all even or odd labels to all leaves of the specified vdev.
	*/
	static void
	vdev_label_sync(zio_t zio, uint64_t good_writes,
	vdev_t *vd, int l, uint64_t txg, int flags)
	{
	nvlist_t *label;
	vdev_phys_t *vp;
	abd_t *vp_abd;
	char *buf;
	size_t buflen;

	for (int c = 0; c < vd->vdev_children; c++) {
	vdev_label_sync(zio, good_writes,
	vd->vdev_child[c], l, txg, flags);
	}

	if (!vd->vdev_ops->vdev_op_leaf)
	return;

	if (!vdev_writeable(vd))
	return;

	/*
	* The top-level config never needs to be written to a distributed
	* spare. When read vdev_dspare_label_read_config() will generate
	* the config for the vdev_label_read_config().
	*/
	if (vd->vdev_ops == &vdev_draid_spare_ops)
	return;

	/*
	* Generate a label describing the top-level config to which we belong.
	*/
	label = spa_config_generate(vd->vdev_spa, vd, txg, B_FALSE);

	vp_abd = abd_alloc_linear(sizeof (vdev_phys_t), B_TRUE);
	abd_zero(vp_abd, sizeof (vdev_phys_t));
	vp = abd_to_buf(vp_abd);

	buf = vp->vp_nvlist;
	buflen = sizeof (vp->vp_nvlist);

	if (!nvlist_pack(label, &buf, &buflen, NV_ENCODE_XDR, KM_SLEEP)) {
	for (; l < VDEV_LABELS; l += 2) {
	vdev_label_write(zio, vd, l, vp_abd,
	offsetof(vdev_label_t, vl_vdev_phys),
	sizeof (vdev_phys_t),
	vdev_label_sync_done, good_writes,
	flags \| ZIO_FLAG_DONT_PROPAGATE);
	}
	}

	abd_free(vp_abd);
	nvlist_free(label);
	}

	static int
	vdev_label_sync_list(spa_t *spa, int l, uint64_t txg, int flags)
	{
	list_t *dl = &spa->spa_config_dirty_list;
	vdev_t *vd;
	zio_t *zio;
	int error;

	/*
	* Write the new labels to disk.
	*/
	zio = zio_root(spa, NULL, NULL, flags);

	for (vd = list_head(dl); vd != NULL; vd = list_next(dl, vd)) {
	uint64_t *good_writes;

	ASSERT(!vd->vdev_ishole);

	good_writes = kmem_zalloc(sizeof (uint64_t), KM_SLEEP);
	zio_t *vio = zio_null(zio, spa, NULL,
	(vd->vdev_islog \|\| vd->vdev_aux != NULL) ?
	vdev_label_sync_ignore_done : vdev_label_sync_top_done,
	good_writes, flags);
	vdev_label_sync(vio, good_writes, vd, l, txg, flags);
	zio_nowait(vio);
	}

	error = zio_wait(zio);

	/*
	* Flush the new labels to disk.
	*/
	zio = zio_root(spa, NULL, NULL, flags);

	for (vd = list_head(dl); vd != NULL; vd = list_next(dl, vd))
	zio_flush(zio, vd);

	(void) zio_wait(zio);

	return (error);
	}

	/*
	* Sync the uberblock and any changes to the vdev configuration.
	*
	* The order of operations is carefully crafted to ensure that
	* if the system panics or loses power at any time, the state on disk
	* is still transactionally consistent. The in-line comments below
	* describe the failure semantics at each stage.
	*
	* Moreover, vdev_config_sync() is designed to be idempotent: if it fails
	* at any time, you can just call it again, and it will resume its work.
	*/
	int
	vdev_config_sync(vdev_t **svd, int svdcount, uint64_t txg)
	{
	spa_t *spa = svd[0]->vdev_spa;
	uberblock_t *ub = &spa->spa_uberblock;
	int error = 0;
	int flags = ZIO_FLAG_CONFIG_WRITER \| ZIO_FLAG_CANFAIL;

	ASSERT(svdcount != 0);
	retry:
	/*
	* Normally, we don't want to try too hard to write every label and
	* uberblock. If there is a flaky disk, we don't want the rest of the
	* sync process to block while we retry. But if we can't write a
	* single label out, we should retry with ZIO_FLAG_TRYHARD before
	* bailing out and declaring the pool faulted.
	*/
	if (error != 0) {
	if ((flags & ZIO_FLAG_TRYHARD) != 0)
	return (error);
	flags \|= ZIO_FLAG_TRYHARD;
	}

	ASSERT(ub->ub_txg <= txg);

	/*
	* If this isn't a resync due to I/O errors,
	* and nothing changed in this transaction group,
	* and the vdev configuration hasn't changed,
	* then there's nothing to do.
	*/
	if (ub->ub_txg < txg) {
	boolean_t changed = uberblock_update(ub, spa->spa_root_vdev,
	txg, spa->spa_mmp.mmp_delay);

	if (!changed && list_is_empty(&spa->spa_config_dirty_list))
	return (0);
	}

	if (txg > spa_freeze_txg(spa))
	return (0);

	ASSERT(txg <= spa->spa_final_txg);

	/*
	* Flush the write cache of every disk that's been written to
	* in this transaction group. This ensures that all blocks
	* written in this txg will be committed to stable storage
	* before any uberblock that references them.
	*/
	zio_t *zio = zio_root(spa, NULL, NULL, flags);

	for (vdev_t *vd =
	txg_list_head(&spa->spa_vdev_txg_list, TXG_CLEAN(txg)); vd != NULL;
	vd = txg_list_next(&spa->spa_vdev_txg_list, vd, TXG_CLEAN(txg)))
	zio_flush(zio, vd);

	(void) zio_wait(zio);

	/*
	* Sync out the even labels (L0, L2) for every dirty vdev. If the
	* system dies in the middle of this process, that's OK: all of the
	* even labels that made it to disk will be newer than any uberblock,
	* and will therefore be considered invalid. The odd labels (L1, L3),
	* which have not yet been touched, will still be valid. We flush
	* the new labels to disk to ensure that all even-label updates
	* are committed to stable storage before the uberblock update.
	*/
	if ((error = vdev_label_sync_list(spa, 0, txg, flags)) != 0) {
	if ((flags & ZIO_FLAG_TRYHARD) != 0) {
	zfs_dbgmsg("vdev_label_sync_list() returned error %d "
	"for pool '%s' when syncing out the even labels "
	"of dirty vdevs", error, spa_name(spa));
	}
	goto retry;
	}

	/*
	* Sync the uberblocks to all vdevs in svd[].
	* If the system dies in the middle of this step, there are two cases
	* to consider, and the on-disk state is consistent either way:
	*
	* (1) If none of the new uberblocks made it to disk, then the
	* previous uberblock will be the newest, and the odd labels
	* (which had not yet been touched) will be valid with respect
	* to that uberblock.
	*
	* (2) If one or more new uberblocks made it to disk, then they
	* will be the newest, and the even labels (which had all
	* been successfully committed) will be valid with respect
	* to the new uberblocks.
	*/
	if ((error = vdev_uberblock_sync_list(svd, svdcount, ub, flags)) != 0) {
	if ((flags & ZIO_FLAG_TRYHARD) != 0) {
	zfs_dbgmsg("vdev_uberblock_sync_list() returned error "
	"%d for pool '%s'", error, spa_name(spa));
	}
	goto retry;
	}

	if (spa_multihost(spa))
	mmp_update_uberblock(spa, ub);

	/*
	* Sync out odd labels for every dirty vdev. If the system dies
	* in the middle of this process, the even labels and the new
	* uberblocks will suffice to open the pool. The next time
	* the pool is opened, the first thing we'll do -- before any
	* user data is modified -- is mark every vdev dirty so that
	* all labels will be brought up to date. We flush the new labels
	* to disk to ensure that all odd-label updates are committed to
	* stable storage before the next transaction group begins.
	*/
	if ((error = vdev_label_sync_list(spa, 1, txg, flags)) != 0) {
	if ((flags & ZIO_FLAG_TRYHARD) != 0) {
	zfs_dbgmsg("vdev_label_sync_list() returned error %d "
	"for pool '%s' when syncing out the odd labels of "
	"dirty vdevs", error, spa_name(spa));
	}
	goto retry;
	}

	return (0);
	}
	diff --git a/sys/contrib/openzfs/module/zfs/vdev_raidz_math_scalar.c b/sys/contrib/openzfs/module/zfs/vdev_raidz_math_scalar.c
	index cd742e146ca6..9e9c15ff4ba2 100644
	--- a/sys/contrib/openzfs/module/zfs/vdev_raidz_math_scalar.c
	+++ b/sys/contrib/openzfs/module/zfs/vdev_raidz_math_scalar.c
	@@ -1,337 +1,337 @@
	/*
	* 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.
	*/

	#include <sys/vdev_raidz_impl.h>

	/*
	* Provide native CPU scalar routines.
	* Support 32bit and 64bit CPUs.
	*/
	#if ((~(0x0ULL)) >> 24) == 0xffULL
	#define ELEM_SIZE 4
	typedef uint32_t iv_t;
	#elif ((~(0x0ULL)) >> 56) == 0xffULL
	#define ELEM_SIZE 8
	typedef uint64_t iv_t;
	#endif

	/*
	* Vector type used in scalar implementation
	*
	* The union is expected to be of native CPU register size. Since addition
	* uses XOR operation, it can be performed an all byte elements at once.
	* Multiplication requires per byte access.
	*/
	typedef union {
	iv_t e;
	uint8_t b[ELEM_SIZE];
	} v_t;

	/*
	* Precomputed lookup tables for multiplication by a constant
	*
	* Reconstruction path requires multiplication by a constant factors. Instead of
	* performing two step lookup (log & exp tables), a direct lookup can be used
	* instead. Multiplication of element 'a' by a constant 'c' is obtained as:
	*
	* r = vdev_raidz_mul_lt[c_log][a];
	*
	* where c_log = vdev_raidz_log2[c]. Log of coefficient factors is used because
	* they are faster to obtain while solving the syndrome equations.
	*
	* PERFORMANCE NOTE:
	* Even though the complete lookup table uses 64kiB, only relatively small
	* portion of it is used at the same time. Following shows number of accessed
	* bytes for different cases:
	* - 1 failed disk: 256B (1 mul. coefficient)
	* - 2 failed disks: 512B (2 mul. coefficients)
	* - 3 failed disks: 1536B (6 mul. coefficients)
	*
	* Size of actually accessed lookup table regions is only larger for
	* reconstruction of 3 failed disks, when compared to traditional log/exp
	* method. But since the result is obtained in one lookup step performance is
	* doubled.
	*/
	static uint8_t vdev_raidz_mul_lt[256][256] __attribute__((aligned(256)));

	static void
	raidz_init_scalar(void)
	{
	int c, i;
	for (c = 0; c < 256; c++)
	for (i = 0; i < 256; i++)
	vdev_raidz_mul_lt[c][i] = gf_mul(c, i);

	}

	#define PREFETCHNTA(ptr, offset) {}
	#define PREFETCH(ptr, offset) {}

	#define XOR_ACC(src, acc) acc.e ^= ((v_t *)src)[0].e
	#define XOR(src, acc) acc.e ^= src.e
	#define ZERO(acc) acc.e = 0
	#define COPY(src, dst) dst = src
	#define LOAD(src, val) val = ((v_t *)src)[0]
	#define STORE(dst, val) ((v_t *)dst)[0] = val

	/*
	* Constants used for optimized multiplication by 2.
	*/
	static const struct {
	iv_t mod;
	iv_t mask;
	iv_t msb;
	} scalar_mul2_consts = {
	#if ELEM_SIZE == 8
	.mod = 0x1d1d1d1d1d1d1d1dULL,
	.mask = 0xfefefefefefefefeULL,
	.msb = 0x8080808080808080ULL,
	#else
	.mod = 0x1d1d1d1dULL,
	.mask = 0xfefefefeULL,
	.msb = 0x80808080ULL,
	#endif
	};

	#define MUL2_SETUP() {}

	#define MUL2(a) \
	{ \
	iv_t _mask; \
	\
	_mask = (a).e & scalar_mul2_consts.msb; \
	_mask = (_mask << 1) - (_mask >> 7); \
	(a).e = ((a).e << 1) & scalar_mul2_consts.mask; \
	(a).e = (a).e ^ (_mask & scalar_mul2_consts.mod); \
	}

	#define MUL4(a) \
	{ \
	MUL2(a); \
	MUL2(a); \
	}

	#define MUL(c, a) \
	{ \
	const uint8_t *mul_lt = vdev_raidz_mul_lt[c]; \
	switch (ELEM_SIZE) { \
	case 8: \
	a.b[7] = mul_lt[a.b[7]]; \
	a.b[6] = mul_lt[a.b[6]]; \
	a.b[5] = mul_lt[a.b[5]]; \
	a.b[4] = mul_lt[a.b[4]]; \
	- /* falls through */ \
	+ fallthrough; \
	case 4: \
	a.b[3] = mul_lt[a.b[3]]; \
	a.b[2] = mul_lt[a.b[2]]; \
	a.b[1] = mul_lt[a.b[1]]; \
	a.b[0] = mul_lt[a.b[0]]; \
	break; \
	} \
	}

	#define raidz_math_begin() {}
	#define raidz_math_end() {}

	#define SYN_STRIDE 1

	#define ZERO_DEFINE() v_t d0
	#define ZERO_STRIDE 1
	#define ZERO_D d0

	#define COPY_DEFINE() v_t d0
	#define COPY_STRIDE 1
	#define COPY_D d0

	#define ADD_DEFINE() v_t d0
	#define ADD_STRIDE 1
	#define ADD_D d0

	#define MUL_DEFINE() v_t d0
	#define MUL_STRIDE 1
	#define MUL_D d0

	#define GEN_P_STRIDE 1
	#define GEN_P_DEFINE() v_t p0
	#define GEN_P_P p0

	#define GEN_PQ_STRIDE 1
	#define GEN_PQ_DEFINE() v_t d0, c0
	#define GEN_PQ_D d0
	#define GEN_PQ_C c0

	#define GEN_PQR_STRIDE 1
	#define GEN_PQR_DEFINE() v_t d0, c0
	#define GEN_PQR_D d0
	#define GEN_PQR_C c0

	#define SYN_Q_DEFINE() v_t d0, x0
	#define SYN_Q_D d0
	#define SYN_Q_X x0


	#define SYN_R_DEFINE() v_t d0, x0
	#define SYN_R_D d0
	#define SYN_R_X x0


	#define SYN_PQ_DEFINE() v_t d0, x0
	#define SYN_PQ_D d0
	#define SYN_PQ_X x0


	#define REC_PQ_STRIDE 1
	#define REC_PQ_DEFINE() v_t x0, y0, t0
	#define REC_PQ_X x0
	#define REC_PQ_Y y0
	#define REC_PQ_T t0


	#define SYN_PR_DEFINE() v_t d0, x0
	#define SYN_PR_D d0
	#define SYN_PR_X x0

	#define REC_PR_STRIDE 1
	#define REC_PR_DEFINE() v_t x0, y0, t0
	#define REC_PR_X x0
	#define REC_PR_Y y0
	#define REC_PR_T t0


	#define SYN_QR_DEFINE() v_t d0, x0
	#define SYN_QR_D d0
	#define SYN_QR_X x0


	#define REC_QR_STRIDE 1
	#define REC_QR_DEFINE() v_t x0, y0, t0
	#define REC_QR_X x0
	#define REC_QR_Y y0
	#define REC_QR_T t0


	#define SYN_PQR_DEFINE() v_t d0, x0
	#define SYN_PQR_D d0
	#define SYN_PQR_X x0

	#define REC_PQR_STRIDE 1
	#define REC_PQR_DEFINE() v_t x0, y0, z0, xs0, ys0
	#define REC_PQR_X x0
	#define REC_PQR_Y y0
	#define REC_PQR_Z z0
	#define REC_PQR_XS xs0
	#define REC_PQR_YS ys0

	#include "vdev_raidz_math_impl.h"

	DEFINE_GEN_METHODS(scalar);
	DEFINE_REC_METHODS(scalar);

	boolean_t
	raidz_will_scalar_work(void)
	{
	return (B_TRUE); /* always */
	}

	const raidz_impl_ops_t vdev_raidz_scalar_impl = {
	.init = raidz_init_scalar,
	.fini = NULL,
	.gen = RAIDZ_GEN_METHODS(scalar),
	.rec = RAIDZ_REC_METHODS(scalar),
	.is_supported = &raidz_will_scalar_work,
	.name = "scalar"
	};

	/* Powers of 2 in the RAID-Z Galois field. */
	const uint8_t vdev_raidz_pow2[256] __attribute__((aligned(256))) = {
	0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80,
	0x1d, 0x3a, 0x74, 0xe8, 0xcd, 0x87, 0x13, 0x26,
	0x4c, 0x98, 0x2d, 0x5a, 0xb4, 0x75, 0xea, 0xc9,
	0x8f, 0x03, 0x06, 0x0c, 0x18, 0x30, 0x60, 0xc0,
	0x9d, 0x27, 0x4e, 0x9c, 0x25, 0x4a, 0x94, 0x35,
	0x6a, 0xd4, 0xb5, 0x77, 0xee, 0xc1, 0x9f, 0x23,
	0x46, 0x8c, 0x05, 0x0a, 0x14, 0x28, 0x50, 0xa0,
	0x5d, 0xba, 0x69, 0xd2, 0xb9, 0x6f, 0xde, 0xa1,
	0x5f, 0xbe, 0x61, 0xc2, 0x99, 0x2f, 0x5e, 0xbc,
	0x65, 0xca, 0x89, 0x0f, 0x1e, 0x3c, 0x78, 0xf0,
	0xfd, 0xe7, 0xd3, 0xbb, 0x6b, 0xd6, 0xb1, 0x7f,
	0xfe, 0xe1, 0xdf, 0xa3, 0x5b, 0xb6, 0x71, 0xe2,
	0xd9, 0xaf, 0x43, 0x86, 0x11, 0x22, 0x44, 0x88,
	0x0d, 0x1a, 0x34, 0x68, 0xd0, 0xbd, 0x67, 0xce,
	0x81, 0x1f, 0x3e, 0x7c, 0xf8, 0xed, 0xc7, 0x93,
	0x3b, 0x76, 0xec, 0xc5, 0x97, 0x33, 0x66, 0xcc,
	0x85, 0x17, 0x2e, 0x5c, 0xb8, 0x6d, 0xda, 0xa9,
	0x4f, 0x9e, 0x21, 0x42, 0x84, 0x15, 0x2a, 0x54,
	0xa8, 0x4d, 0x9a, 0x29, 0x52, 0xa4, 0x55, 0xaa,
	0x49, 0x92, 0x39, 0x72, 0xe4, 0xd5, 0xb7, 0x73,
	0xe6, 0xd1, 0xbf, 0x63, 0xc6, 0x91, 0x3f, 0x7e,
	0xfc, 0xe5, 0xd7, 0xb3, 0x7b, 0xf6, 0xf1, 0xff,
	0xe3, 0xdb, 0xab, 0x4b, 0x96, 0x31, 0x62, 0xc4,
	0x95, 0x37, 0x6e, 0xdc, 0xa5, 0x57, 0xae, 0x41,
	0x82, 0x19, 0x32, 0x64, 0xc8, 0x8d, 0x07, 0x0e,
	0x1c, 0x38, 0x70, 0xe0, 0xdd, 0xa7, 0x53, 0xa6,
	0x51, 0xa2, 0x59, 0xb2, 0x79, 0xf2, 0xf9, 0xef,
	0xc3, 0x9b, 0x2b, 0x56, 0xac, 0x45, 0x8a, 0x09,
	0x12, 0x24, 0x48, 0x90, 0x3d, 0x7a, 0xf4, 0xf5,
	0xf7, 0xf3, 0xfb, 0xeb, 0xcb, 0x8b, 0x0b, 0x16,
	0x2c, 0x58, 0xb0, 0x7d, 0xfa, 0xe9, 0xcf, 0x83,
	0x1b, 0x36, 0x6c, 0xd8, 0xad, 0x47, 0x8e, 0x01
	};

	/* Logs of 2 in the RAID-Z Galois field. */
	const uint8_t vdev_raidz_log2[256] __attribute__((aligned(256))) = {
	0x00, 0x00, 0x01, 0x19, 0x02, 0x32, 0x1a, 0xc6,
	0x03, 0xdf, 0x33, 0xee, 0x1b, 0x68, 0xc7, 0x4b,
	0x04, 0x64, 0xe0, 0x0e, 0x34, 0x8d, 0xef, 0x81,
	0x1c, 0xc1, 0x69, 0xf8, 0xc8, 0x08, 0x4c, 0x71,
	0x05, 0x8a, 0x65, 0x2f, 0xe1, 0x24, 0x0f, 0x21,
	0x35, 0x93, 0x8e, 0xda, 0xf0, 0x12, 0x82, 0x45,
	0x1d, 0xb5, 0xc2, 0x7d, 0x6a, 0x27, 0xf9, 0xb9,
	0xc9, 0x9a, 0x09, 0x78, 0x4d, 0xe4, 0x72, 0xa6,
	0x06, 0xbf, 0x8b, 0x62, 0x66, 0xdd, 0x30, 0xfd,
	0xe2, 0x98, 0x25, 0xb3, 0x10, 0x91, 0x22, 0x88,
	0x36, 0xd0, 0x94, 0xce, 0x8f, 0x96, 0xdb, 0xbd,
	0xf1, 0xd2, 0x13, 0x5c, 0x83, 0x38, 0x46, 0x40,
	0x1e, 0x42, 0xb6, 0xa3, 0xc3, 0x48, 0x7e, 0x6e,
	0x6b, 0x3a, 0x28, 0x54, 0xfa, 0x85, 0xba, 0x3d,
	0xca, 0x5e, 0x9b, 0x9f, 0x0a, 0x15, 0x79, 0x2b,
	0x4e, 0xd4, 0xe5, 0xac, 0x73, 0xf3, 0xa7, 0x57,
	0x07, 0x70, 0xc0, 0xf7, 0x8c, 0x80, 0x63, 0x0d,
	0x67, 0x4a, 0xde, 0xed, 0x31, 0xc5, 0xfe, 0x18,
	0xe3, 0xa5, 0x99, 0x77, 0x26, 0xb8, 0xb4, 0x7c,
	0x11, 0x44, 0x92, 0xd9, 0x23, 0x20, 0x89, 0x2e,
	0x37, 0x3f, 0xd1, 0x5b, 0x95, 0xbc, 0xcf, 0xcd,
	0x90, 0x87, 0x97, 0xb2, 0xdc, 0xfc, 0xbe, 0x61,
	0xf2, 0x56, 0xd3, 0xab, 0x14, 0x2a, 0x5d, 0x9e,
	0x84, 0x3c, 0x39, 0x53, 0x47, 0x6d, 0x41, 0xa2,
	0x1f, 0x2d, 0x43, 0xd8, 0xb7, 0x7b, 0xa4, 0x76,
	0xc4, 0x17, 0x49, 0xec, 0x7f, 0x0c, 0x6f, 0xf6,
	0x6c, 0xa1, 0x3b, 0x52, 0x29, 0x9d, 0x55, 0xaa,
	0xfb, 0x60, 0x86, 0xb1, 0xbb, 0xcc, 0x3e, 0x5a,
	0xcb, 0x59, 0x5f, 0xb0, 0x9c, 0xa9, 0xa0, 0x51,
	0x0b, 0xf5, 0x16, 0xeb, 0x7a, 0x75, 0x2c, 0xd7,
	0x4f, 0xae, 0xd5, 0xe9, 0xe6, 0xe7, 0xad, 0xe8,
	0x74, 0xd6, 0xf4, 0xea, 0xa8, 0x50, 0x58, 0xaf,
	};
	diff --git a/sys/contrib/openzfs/module/zfs/zfs_replay.c b/sys/contrib/openzfs/module/zfs/zfs_replay.c
	index cba5e8c9cd0b..f3d209f1fbdb 100644
	--- a/sys/contrib/openzfs/module/zfs/zfs_replay.c
	+++ b/sys/contrib/openzfs/module/zfs/zfs_replay.c
	@@ -1,992 +1,990 @@
	/*
	* 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 Cyril Plisko. All rights reserved.
	* Copyright (c) 2013, 2017 by Delphix. All rights reserved.
	*/

	#include <sys/types.h>
	#include <sys/param.h>
	#include <sys/sysmacros.h>
	#include <sys/cmn_err.h>
	#include <sys/kmem.h>
	#include <sys/thread.h>
	#include <sys/file.h>
	#include <sys/fcntl.h>
	#include <sys/vfs.h>
	#include <sys/fs/zfs.h>
	#include <sys/zfs_znode.h>
	#include <sys/zfs_dir.h>
	#include <sys/zfs_acl.h>
	#include <sys/zfs_fuid.h>
	#include <sys/zfs_vnops.h>
	#include <sys/spa.h>
	#include <sys/zil.h>
	#include <sys/byteorder.h>
	#include <sys/stat.h>
	#include <sys/acl.h>
	#include <sys/atomic.h>
	#include <sys/cred.h>
	#include <sys/zpl.h>

	/*
	* NB: FreeBSD expects to be able to do vnode locking in lookup and
	* hold the locks across all subsequent VOPs until vput is called.
	* This means that its zfs vnops routines can't do any internal locking.
	* In order to have the same contract as the Linux vnops there would
	* needed to be duplicate locked vnops. If the vnops were used more widely
	* in common code this would likely be preferable. However, currently
	* this is the only file where this is the case.
	*/

	/*
	* Functions to replay ZFS intent log (ZIL) records
	* The functions are called through a function vector (zfs_replay_vector)
	* which is indexed by the transaction type.
	*/

	static void
	zfs_init_vattr(vattr_t *vap, uint64_t mask, uint64_t mode,
	uint64_t uid, uint64_t gid, uint64_t rdev, uint64_t nodeid)
	{
	bzero(vap, sizeof (*vap));
	vap->va_mask = (uint_t)mask;
	vap->va_mode = mode;
	#ifdef __FreeBSD__
	vap->va_type = IFTOVT(mode);
	#endif
	vap->va_uid = (uid_t)(IS_EPHEMERAL(uid)) ? -1 : uid;
	vap->va_gid = (gid_t)(IS_EPHEMERAL(gid)) ? -1 : gid;
	vap->va_rdev = zfs_cmpldev(rdev);
	vap->va_nodeid = nodeid;
	}

	/* ARGSUSED */
	static int
	zfs_replay_error(void arg1, void arg2, boolean_t byteswap)
	{
	return (SET_ERROR(ENOTSUP));
	}

	static void
	zfs_replay_xvattr(lr_attr_t lrattr, xvattr_t xvap)
	{
	xoptattr_t *xoap = NULL;
	uint64_t *attrs;
	uint64_t *crtime;
	uint32_t *bitmap;
	void *scanstamp;
	int i;

	xvap->xva_vattr.va_mask \|= ATTR_XVATTR;
	if ((xoap = xva_getxoptattr(xvap)) == NULL) {
	xvap->xva_vattr.va_mask &= ~ATTR_XVATTR; /* shouldn't happen */
	return;
	}

	ASSERT(lrattr->lr_attr_masksize == xvap->xva_mapsize);

	bitmap = &lrattr->lr_attr_bitmap;
	for (i = 0; i != lrattr->lr_attr_masksize; i++, bitmap++)
	xvap->xva_reqattrmap[i] = *bitmap;

	attrs = (uint64_t *)(lrattr + lrattr->lr_attr_masksize - 1);
	crtime = attrs + 1;
	scanstamp = (caddr_t)(crtime + 2);

	if (XVA_ISSET_REQ(xvap, XAT_HIDDEN))
	xoap->xoa_hidden = ((*attrs & XAT0_HIDDEN) != 0);
	if (XVA_ISSET_REQ(xvap, XAT_SYSTEM))
	xoap->xoa_system = ((*attrs & XAT0_SYSTEM) != 0);
	if (XVA_ISSET_REQ(xvap, XAT_ARCHIVE))
	xoap->xoa_archive = ((*attrs & XAT0_ARCHIVE) != 0);
	if (XVA_ISSET_REQ(xvap, XAT_READONLY))
	xoap->xoa_readonly = ((*attrs & XAT0_READONLY) != 0);
	if (XVA_ISSET_REQ(xvap, XAT_IMMUTABLE))
	xoap->xoa_immutable = ((*attrs & XAT0_IMMUTABLE) != 0);
	if (XVA_ISSET_REQ(xvap, XAT_NOUNLINK))
	xoap->xoa_nounlink = ((*attrs & XAT0_NOUNLINK) != 0);
	if (XVA_ISSET_REQ(xvap, XAT_APPENDONLY))
	xoap->xoa_appendonly = ((*attrs & XAT0_APPENDONLY) != 0);
	if (XVA_ISSET_REQ(xvap, XAT_NODUMP))
	xoap->xoa_nodump = ((*attrs & XAT0_NODUMP) != 0);
	if (XVA_ISSET_REQ(xvap, XAT_OPAQUE))
	xoap->xoa_opaque = ((*attrs & XAT0_OPAQUE) != 0);
	if (XVA_ISSET_REQ(xvap, XAT_AV_MODIFIED))
	xoap->xoa_av_modified = ((*attrs & XAT0_AV_MODIFIED) != 0);
	if (XVA_ISSET_REQ(xvap, XAT_AV_QUARANTINED))
	xoap->xoa_av_quarantined =
	((*attrs & XAT0_AV_QUARANTINED) != 0);
	if (XVA_ISSET_REQ(xvap, XAT_CREATETIME))
	ZFS_TIME_DECODE(&xoap->xoa_createtime, crtime);
	if (XVA_ISSET_REQ(xvap, XAT_AV_SCANSTAMP)) {
	ASSERT(!XVA_ISSET_REQ(xvap, XAT_PROJID));

	bcopy(scanstamp, xoap->xoa_av_scanstamp, AV_SCANSTAMP_SZ);
	} else if (XVA_ISSET_REQ(xvap, XAT_PROJID)) {
	/*
	* XAT_PROJID and XAT_AV_SCANSTAMP will never be valid
	* at the same time, so we can share the same space.
	*/
	bcopy(scanstamp, &xoap->xoa_projid, sizeof (uint64_t));
	}
	if (XVA_ISSET_REQ(xvap, XAT_REPARSE))
	xoap->xoa_reparse = ((*attrs & XAT0_REPARSE) != 0);
	if (XVA_ISSET_REQ(xvap, XAT_OFFLINE))
	xoap->xoa_offline = ((*attrs & XAT0_OFFLINE) != 0);
	if (XVA_ISSET_REQ(xvap, XAT_SPARSE))
	xoap->xoa_sparse = ((*attrs & XAT0_SPARSE) != 0);
	if (XVA_ISSET_REQ(xvap, XAT_PROJINHERIT))
	xoap->xoa_projinherit = ((*attrs & XAT0_PROJINHERIT) != 0);
	}

	static int
	zfs_replay_domain_cnt(uint64_t uid, uint64_t gid)
	{
	uint64_t uid_idx;
	uint64_t gid_idx;
	int domcnt = 0;

	uid_idx = FUID_INDEX(uid);
	gid_idx = FUID_INDEX(gid);
	if (uid_idx)
	domcnt++;
	if (gid_idx > 0 && gid_idx != uid_idx)
	domcnt++;

	return (domcnt);
	}

	static void *
	zfs_replay_fuid_domain_common(zfs_fuid_info_t fuid_infop, void start,
	int domcnt)
	{
	int i;

	for (i = 0; i != domcnt; i++) {
	fuid_infop->z_domain_table[i] = start;
	start = (caddr_t)start + strlen(start) + 1;
	}

	return (start);
	}

	/*
	* Set the uid/gid in the fuid_info structure.
	*/
	static void
	zfs_replay_fuid_ugid(zfs_fuid_info_t *fuid_infop, uint64_t uid, uint64_t gid)
	{
	/*
	* If owner or group are log specific FUIDs then slurp up
	* domain information and build zfs_fuid_info_t
	*/
	if (IS_EPHEMERAL(uid))
	fuid_infop->z_fuid_owner = uid;

	if (IS_EPHEMERAL(gid))
	fuid_infop->z_fuid_group = gid;
	}

	/*
	* Load fuid domains into fuid_info_t
	*/
	static zfs_fuid_info_t *
	zfs_replay_fuid_domain(void buf, void *end, uint64_t uid, uint64_t gid)
	{
	int domcnt;

	zfs_fuid_info_t *fuid_infop;

	fuid_infop = zfs_fuid_info_alloc();

	domcnt = zfs_replay_domain_cnt(uid, gid);

	if (domcnt == 0)
	return (fuid_infop);

	fuid_infop->z_domain_table =
	kmem_zalloc(domcnt * sizeof (char *), KM_SLEEP);

	zfs_replay_fuid_ugid(fuid_infop, uid, gid);

	fuid_infop->z_domain_cnt = domcnt;
	*end = zfs_replay_fuid_domain_common(fuid_infop, buf, domcnt);
	return (fuid_infop);
	}

	/*
	* load zfs_fuid_t's and fuid_domains into fuid_info_t
	*/
	static zfs_fuid_info_t *
	zfs_replay_fuids(void start, void *end, int idcnt, int domcnt, uint64_t uid,
	uint64_t gid)
	{
	uint64_t log_fuid = (uint64_t )start;
	zfs_fuid_info_t *fuid_infop;
	int i;

	fuid_infop = zfs_fuid_info_alloc();
	fuid_infop->z_domain_cnt = domcnt;

	fuid_infop->z_domain_table =
	kmem_zalloc(domcnt * sizeof (char *), KM_SLEEP);

	for (i = 0; i != idcnt; i++) {
	zfs_fuid_t *zfuid;

	zfuid = kmem_alloc(sizeof (zfs_fuid_t), KM_SLEEP);
	zfuid->z_logfuid = *log_fuid;
	zfuid->z_id = -1;
	zfuid->z_domidx = 0;
	list_insert_tail(&fuid_infop->z_fuids, zfuid);
	log_fuid++;
	}

	zfs_replay_fuid_ugid(fuid_infop, uid, gid);

	*end = zfs_replay_fuid_domain_common(fuid_infop, log_fuid, domcnt);
	return (fuid_infop);
	}

	static void
	zfs_replay_swap_attrs(lr_attr_t *lrattr)
	{
	/* swap the lr_attr structure */
	byteswap_uint32_array(lrattr, sizeof (*lrattr));
	/* swap the bitmap */
	byteswap_uint32_array(lrattr + 1, (lrattr->lr_attr_masksize - 1) *
	sizeof (uint32_t));
	/* swap the attributes, create time + 64 bit word for attributes */
	byteswap_uint64_array((caddr_t)(lrattr + 1) + (sizeof (uint32_t) *
	(lrattr->lr_attr_masksize - 1)), 3 * sizeof (uint64_t));
	}

	/*
	* Replay file create with optional ACL, xvattr information as well
	* as option FUID information.
	*/
	static int
	zfs_replay_create_acl(void arg1, void arg2, boolean_t byteswap)
	{
	zfsvfs_t *zfsvfs = arg1;
	lr_acl_create_t *lracl = arg2;
	char name = NULL; / location determined later */
	lr_create_t lr = (lr_create_t )lracl;
	znode_t *dzp;
	znode_t *zp;
	xvattr_t xva;
	int vflg = 0;
	vsecattr_t vsec = { 0 };
	lr_attr_t *lrattr;
	void *aclstart;
	void *fuidstart;
	size_t xvatlen = 0;
	uint64_t txtype;
	uint64_t objid;
	uint64_t dnodesize;
	int error;

	txtype = (lr->lr_common.lrc_txtype & ~TX_CI);
	if (byteswap) {
	byteswap_uint64_array(lracl, sizeof (*lracl));
	if (txtype == TX_CREATE_ACL_ATTR \|\|
	txtype == TX_MKDIR_ACL_ATTR) {
	lrattr = (lr_attr_t *)(caddr_t)(lracl + 1);
	zfs_replay_swap_attrs(lrattr);
	xvatlen = ZIL_XVAT_SIZE(lrattr->lr_attr_masksize);
	}

	aclstart = (caddr_t)(lracl + 1) + xvatlen;
	zfs_ace_byteswap(aclstart, lracl->lr_acl_bytes, B_FALSE);
	/* swap fuids */
	if (lracl->lr_fuidcnt) {
	byteswap_uint64_array((caddr_t)aclstart +
	ZIL_ACE_LENGTH(lracl->lr_acl_bytes),
	lracl->lr_fuidcnt * sizeof (uint64_t));
	}
	}

	if ((error = zfs_zget(zfsvfs, lr->lr_doid, &dzp)) != 0)
	return (error);

	objid = LR_FOID_GET_OBJ(lr->lr_foid);
	dnodesize = LR_FOID_GET_SLOTS(lr->lr_foid) << DNODE_SHIFT;

	xva_init(&xva);
	zfs_init_vattr(&xva.xva_vattr, ATTR_MODE \| ATTR_UID \| ATTR_GID,
	lr->lr_mode, lr->lr_uid, lr->lr_gid, lr->lr_rdev, objid);

	/*
	* All forms of zfs create (create, mkdir, mkxattrdir, symlink)
	* eventually end up in zfs_mknode(), which assigns the object's
	* creation time, generation number, and dnode size. The generic
	* zfs_create() has no concept of these attributes, so we smuggle
	* the values inside the vattr's otherwise unused va_ctime,
	* va_nblocks, and va_fsid fields.
	*/
	ZFS_TIME_DECODE(&xva.xva_vattr.va_ctime, lr->lr_crtime);
	xva.xva_vattr.va_nblocks = lr->lr_gen;
	xva.xva_vattr.va_fsid = dnodesize;

	error = dnode_try_claim(zfsvfs->z_os, objid, dnodesize >> DNODE_SHIFT);
	if (error)
	goto bail;

	if (lr->lr_common.lrc_txtype & TX_CI)
	vflg \|= FIGNORECASE;
	switch (txtype) {
	case TX_CREATE_ACL:
	aclstart = (caddr_t)(lracl + 1);
	fuidstart = (caddr_t)aclstart +
	ZIL_ACE_LENGTH(lracl->lr_acl_bytes);
	zfsvfs->z_fuid_replay = zfs_replay_fuids(fuidstart,
	(void *)&name, lracl->lr_fuidcnt, lracl->lr_domcnt,
	lr->lr_uid, lr->lr_gid);
	- /FALLTHROUGH/
	+ fallthrough;
	case TX_CREATE_ACL_ATTR:
	if (name == NULL) {
	lrattr = (lr_attr_t *)(caddr_t)(lracl + 1);
	xvatlen = ZIL_XVAT_SIZE(lrattr->lr_attr_masksize);
	xva.xva_vattr.va_mask \|= ATTR_XVATTR;
	zfs_replay_xvattr(lrattr, &xva);
	}
	vsec.vsa_mask = VSA_ACE \| VSA_ACE_ACLFLAGS;
	vsec.vsa_aclentp = (caddr_t)(lracl + 1) + xvatlen;
	vsec.vsa_aclcnt = lracl->lr_aclcnt;
	vsec.vsa_aclentsz = lracl->lr_acl_bytes;
	vsec.vsa_aclflags = lracl->lr_acl_flags;
	if (zfsvfs->z_fuid_replay == NULL) {
	fuidstart = (caddr_t)(lracl + 1) + xvatlen +
	ZIL_ACE_LENGTH(lracl->lr_acl_bytes);
	zfsvfs->z_fuid_replay =
	zfs_replay_fuids(fuidstart,
	(void *)&name, lracl->lr_fuidcnt, lracl->lr_domcnt,
	lr->lr_uid, lr->lr_gid);
	}

	error = zfs_create(dzp, name, &xva.xva_vattr,
	0, 0, &zp, kcred, vflg, &vsec);
	break;
	case TX_MKDIR_ACL:
	aclstart = (caddr_t)(lracl + 1);
	fuidstart = (caddr_t)aclstart +
	ZIL_ACE_LENGTH(lracl->lr_acl_bytes);
	zfsvfs->z_fuid_replay = zfs_replay_fuids(fuidstart,
	(void *)&name, lracl->lr_fuidcnt, lracl->lr_domcnt,
	lr->lr_uid, lr->lr_gid);
	- /FALLTHROUGH/
	+ fallthrough;
	case TX_MKDIR_ACL_ATTR:
	if (name == NULL) {
	lrattr = (lr_attr_t *)(caddr_t)(lracl + 1);
	xvatlen = ZIL_XVAT_SIZE(lrattr->lr_attr_masksize);
	zfs_replay_xvattr(lrattr, &xva);
	}
	vsec.vsa_mask = VSA_ACE \| VSA_ACE_ACLFLAGS;
	vsec.vsa_aclentp = (caddr_t)(lracl + 1) + xvatlen;
	vsec.vsa_aclcnt = lracl->lr_aclcnt;
	vsec.vsa_aclentsz = lracl->lr_acl_bytes;
	vsec.vsa_aclflags = lracl->lr_acl_flags;
	if (zfsvfs->z_fuid_replay == NULL) {
	fuidstart = (caddr_t)(lracl + 1) + xvatlen +
	ZIL_ACE_LENGTH(lracl->lr_acl_bytes);
	zfsvfs->z_fuid_replay =
	zfs_replay_fuids(fuidstart,
	(void *)&name, lracl->lr_fuidcnt, lracl->lr_domcnt,
	lr->lr_uid, lr->lr_gid);
	}
	error = zfs_mkdir(dzp, name, &xva.xva_vattr,
	&zp, kcred, vflg, &vsec);
	break;
	default:
	error = SET_ERROR(ENOTSUP);
	}

	bail:
	if (error == 0 && zp != NULL) {
	#ifdef __FreeBSD__
	VOP_UNLOCK1(ZTOV(zp));
	#endif
	zrele(zp);
	}
	zrele(dzp);

	if (zfsvfs->z_fuid_replay)
	zfs_fuid_info_free(zfsvfs->z_fuid_replay);
	zfsvfs->z_fuid_replay = NULL;

	return (error);
	}

	static int
	zfs_replay_create(void arg1, void arg2, boolean_t byteswap)
	{
	zfsvfs_t *zfsvfs = arg1;
	lr_create_t *lr = arg2;
	char name = NULL; / location determined later */
	char link; / symlink content follows name */
	znode_t *dzp;
	znode_t *zp = NULL;
	xvattr_t xva;
	int vflg = 0;
	size_t lrsize = sizeof (lr_create_t);
	lr_attr_t *lrattr;
	void *start;
	size_t xvatlen;
	uint64_t txtype;
	uint64_t objid;
	uint64_t dnodesize;
	int error;

	txtype = (lr->lr_common.lrc_txtype & ~TX_CI);
	if (byteswap) {
	byteswap_uint64_array(lr, sizeof (*lr));
	if (txtype == TX_CREATE_ATTR \|\| txtype == TX_MKDIR_ATTR)
	zfs_replay_swap_attrs((lr_attr_t *)(lr + 1));
	}


	if ((error = zfs_zget(zfsvfs, lr->lr_doid, &dzp)) != 0)
	return (error);

	objid = LR_FOID_GET_OBJ(lr->lr_foid);
	dnodesize = LR_FOID_GET_SLOTS(lr->lr_foid) << DNODE_SHIFT;

	xva_init(&xva);
	zfs_init_vattr(&xva.xva_vattr, ATTR_MODE \| ATTR_UID \| ATTR_GID,
	lr->lr_mode, lr->lr_uid, lr->lr_gid, lr->lr_rdev, objid);

	/*
	* All forms of zfs create (create, mkdir, mkxattrdir, symlink)
	* eventually end up in zfs_mknode(), which assigns the object's
	* creation time, generation number, and dnode slot count. The
	* generic zfs_create() has no concept of these attributes, so
	* we smuggle the values inside the vattr's otherwise unused
	* va_ctime, va_nblocks, and va_fsid fields.
	*/
	ZFS_TIME_DECODE(&xva.xva_vattr.va_ctime, lr->lr_crtime);
	xva.xva_vattr.va_nblocks = lr->lr_gen;
	xva.xva_vattr.va_fsid = dnodesize;

	error = dnode_try_claim(zfsvfs->z_os, objid, dnodesize >> DNODE_SHIFT);
	if (error)
	goto out;

	if (lr->lr_common.lrc_txtype & TX_CI)
	vflg \|= FIGNORECASE;

	/*
	* Symlinks don't have fuid info, and CIFS never creates
	* symlinks.
	*
	* The _ATTR versions will grab the fuid info in their subcases.
	*/
	if ((int)lr->lr_common.lrc_txtype != TX_SYMLINK &&
	(int)lr->lr_common.lrc_txtype != TX_MKDIR_ATTR &&
	(int)lr->lr_common.lrc_txtype != TX_CREATE_ATTR) {
	start = (lr + 1);
	zfsvfs->z_fuid_replay =
	zfs_replay_fuid_domain(start, &start,
	lr->lr_uid, lr->lr_gid);
	}

	switch (txtype) {
	case TX_CREATE_ATTR:
	lrattr = (lr_attr_t *)(caddr_t)(lr + 1);
	xvatlen = ZIL_XVAT_SIZE(lrattr->lr_attr_masksize);
	zfs_replay_xvattr((lr_attr_t *)((caddr_t)lr + lrsize), &xva);
	start = (caddr_t)(lr + 1) + xvatlen;
	zfsvfs->z_fuid_replay =
	zfs_replay_fuid_domain(start, &start,
	lr->lr_uid, lr->lr_gid);
	name = (char *)start;
	-
	- /FALLTHROUGH/
	+ fallthrough;
	case TX_CREATE:
	if (name == NULL)
	name = (char *)start;

	error = zfs_create(dzp, name, &xva.xva_vattr,
	0, 0, &zp, kcred, vflg, NULL);
	break;
	case TX_MKDIR_ATTR:
	lrattr = (lr_attr_t *)(caddr_t)(lr + 1);
	xvatlen = ZIL_XVAT_SIZE(lrattr->lr_attr_masksize);
	zfs_replay_xvattr((lr_attr_t *)((caddr_t)lr + lrsize), &xva);
	start = (caddr_t)(lr + 1) + xvatlen;
	zfsvfs->z_fuid_replay =
	zfs_replay_fuid_domain(start, &start,
	lr->lr_uid, lr->lr_gid);
	name = (char *)start;
	-
	- /FALLTHROUGH/
	+ fallthrough;
	case TX_MKDIR:
	if (name == NULL)
	name = (char *)(lr + 1);

	error = zfs_mkdir(dzp, name, &xva.xva_vattr,
	&zp, kcred, vflg, NULL);
	break;
	case TX_MKXATTR:
	error = zfs_make_xattrdir(dzp, &xva.xva_vattr, &zp, kcred);
	break;
	case TX_SYMLINK:
	name = (char *)(lr + 1);
	link = name + strlen(name) + 1;
	error = zfs_symlink(dzp, name, &xva.xva_vattr,
	link, &zp, kcred, vflg);
	break;
	default:
	error = SET_ERROR(ENOTSUP);
	}

	out:
	if (error == 0 && zp != NULL) {
	#ifdef __FreeBSD__
	VOP_UNLOCK1(ZTOV(zp));
	#endif
	zrele(zp);
	}
	zrele(dzp);

	if (zfsvfs->z_fuid_replay)
	zfs_fuid_info_free(zfsvfs->z_fuid_replay);
	zfsvfs->z_fuid_replay = NULL;
	return (error);
	}

	static int
	zfs_replay_remove(void arg1, void arg2, boolean_t byteswap)
	{
	zfsvfs_t *zfsvfs = arg1;
	lr_remove_t *lr = arg2;
	char name = (char )(lr + 1); /* name follows lr_remove_t */
	znode_t *dzp;
	int error;
	int vflg = 0;

	if (byteswap)
	byteswap_uint64_array(lr, sizeof (*lr));

	if ((error = zfs_zget(zfsvfs, lr->lr_doid, &dzp)) != 0)
	return (error);

	if (lr->lr_common.lrc_txtype & TX_CI)
	vflg \|= FIGNORECASE;

	switch ((int)lr->lr_common.lrc_txtype) {
	case TX_REMOVE:
	error = zfs_remove(dzp, name, kcred, vflg);
	break;
	case TX_RMDIR:
	error = zfs_rmdir(dzp, name, NULL, kcred, vflg);
	break;
	default:
	error = SET_ERROR(ENOTSUP);
	}

	zrele(dzp);

	return (error);
	}

	static int
	zfs_replay_link(void arg1, void arg2, boolean_t byteswap)
	{
	zfsvfs_t *zfsvfs = arg1;
	lr_link_t *lr = arg2;
	char name = (char )(lr + 1); /* name follows lr_link_t */
	znode_t dzp, zp;
	int error;
	int vflg = 0;

	if (byteswap)
	byteswap_uint64_array(lr, sizeof (*lr));

	if ((error = zfs_zget(zfsvfs, lr->lr_doid, &dzp)) != 0)
	return (error);

	if ((error = zfs_zget(zfsvfs, lr->lr_link_obj, &zp)) != 0) {
	zrele(dzp);
	return (error);
	}

	if (lr->lr_common.lrc_txtype & TX_CI)
	vflg \|= FIGNORECASE;

	error = zfs_link(dzp, zp, name, kcred, vflg);
	zrele(zp);
	zrele(dzp);

	return (error);
	}

	static int
	zfs_replay_rename(void arg1, void arg2, boolean_t byteswap)
	{
	zfsvfs_t *zfsvfs = arg1;
	lr_rename_t *lr = arg2;
	char sname = (char )(lr + 1); /* sname and tname follow lr_rename_t */
	char *tname = sname + strlen(sname) + 1;
	znode_t sdzp, tdzp;
	int error;
	int vflg = 0;

	if (byteswap)
	byteswap_uint64_array(lr, sizeof (*lr));

	if ((error = zfs_zget(zfsvfs, lr->lr_sdoid, &sdzp)) != 0)
	return (error);

	if ((error = zfs_zget(zfsvfs, lr->lr_tdoid, &tdzp)) != 0) {
	zrele(sdzp);
	return (error);
	}

	if (lr->lr_common.lrc_txtype & TX_CI)
	vflg \|= FIGNORECASE;

	error = zfs_rename(sdzp, sname, tdzp, tname, kcred, vflg);

	zrele(tdzp);
	zrele(sdzp);
	return (error);
	}

	static int
	zfs_replay_write(void arg1, void arg2, boolean_t byteswap)
	{
	zfsvfs_t *zfsvfs = arg1;
	lr_write_t *lr = arg2;
	char data = (char )(lr + 1); /* data follows lr_write_t */
	znode_t *zp;
	int error;
	uint64_t eod, offset, length;

	if (byteswap)
	byteswap_uint64_array(lr, sizeof (*lr));

	if ((error = zfs_zget(zfsvfs, lr->lr_foid, &zp)) != 0) {
	/*
	* As we can log writes out of order, it's possible the
	* file has been removed. In this case just drop the write
	* and return success.
	*/
	if (error == ENOENT)
	error = 0;
	return (error);
	}

	offset = lr->lr_offset;
	length = lr->lr_length;
	eod = offset + length; /* end of data for this write */

	/*
	* This may be a write from a dmu_sync() for a whole block,
	* and may extend beyond the current end of the file.
	* We can't just replay what was written for this TX_WRITE as
	* a future TX_WRITE2 may extend the eof and the data for that
	* write needs to be there. So we write the whole block and
	* reduce the eof. This needs to be done within the single dmu
	* transaction created within vn_rdwr -> zfs_write. So a possible
	* new end of file is passed through in zfsvfs->z_replay_eof
	*/

	zfsvfs->z_replay_eof = 0; /* 0 means don't change end of file */

	/* 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 (zp->z_size < eod)
	zfsvfs->z_replay_eof = eod;
	}
	error = zfs_write_simple(zp, data, length, offset, NULL);
	zrele(zp);
	zfsvfs->z_replay_eof = 0; /* safety */

	return (error);
	}

	/*
	* TX_WRITE2 are only generated when dmu_sync() returns EALREADY
	* meaning the pool block is already being synced. So now that we always write
	* out full blocks, all we have to do is expand the eof if
	* the file is grown.
	*/
	static int
	zfs_replay_write2(void arg1, void arg2, boolean_t byteswap)
	{
	zfsvfs_t *zfsvfs = arg1;
	lr_write_t *lr = arg2;
	znode_t *zp;
	int error;
	uint64_t end;

	if (byteswap)
	byteswap_uint64_array(lr, sizeof (*lr));

	if ((error = zfs_zget(zfsvfs, lr->lr_foid, &zp)) != 0)
	return (error);

	top:
	end = lr->lr_offset + lr->lr_length;
	if (end > zp->z_size) {
	dmu_tx_t *tx = dmu_tx_create(zfsvfs->z_os);

	zp->z_size = end;
	dmu_tx_hold_sa(tx, zp->z_sa_hdl, B_FALSE);
	error = dmu_tx_assign(tx, TXG_WAIT);
	if (error) {
	zrele(zp);
	if (error == ERESTART) {
	dmu_tx_wait(tx);
	dmu_tx_abort(tx);
	goto top;
	}
	dmu_tx_abort(tx);
	return (error);
	}
	(void) sa_update(zp->z_sa_hdl, SA_ZPL_SIZE(zfsvfs),
	(void *)&zp->z_size, sizeof (uint64_t), tx);

	/* Ensure the replayed seq is updated */
	(void) zil_replaying(zfsvfs->z_log, tx);

	dmu_tx_commit(tx);
	}

	zrele(zp);

	return (error);
	}

	static int
	zfs_replay_truncate(void arg1, void arg2, boolean_t byteswap)
	{
	zfsvfs_t *zfsvfs = arg1;
	lr_truncate_t *lr = arg2;
	znode_t *zp;
	flock64_t fl;
	int error;

	if (byteswap)
	byteswap_uint64_array(lr, sizeof (*lr));

	if ((error = zfs_zget(zfsvfs, lr->lr_foid, &zp)) != 0)
	return (error);

	bzero(&fl, sizeof (fl));
	fl.l_type = F_WRLCK;
	fl.l_whence = SEEK_SET;
	fl.l_start = lr->lr_offset;
	fl.l_len = lr->lr_length;

	error = zfs_space(zp, F_FREESP, &fl, O_RDWR \| O_LARGEFILE,
	lr->lr_offset, kcred);

	zrele(zp);

	return (error);
	}

	static int
	zfs_replay_setattr(void arg1, void arg2, boolean_t byteswap)
	{
	zfsvfs_t *zfsvfs = arg1;
	lr_setattr_t *lr = arg2;
	znode_t *zp;
	xvattr_t xva;
	vattr_t *vap = &xva.xva_vattr;
	int error;
	void *start;

	xva_init(&xva);
	if (byteswap) {
	byteswap_uint64_array(lr, sizeof (*lr));

	if ((lr->lr_mask & ATTR_XVATTR) &&
	zfsvfs->z_version >= ZPL_VERSION_INITIAL)
	zfs_replay_swap_attrs((lr_attr_t *)(lr + 1));
	}

	if ((error = zfs_zget(zfsvfs, lr->lr_foid, &zp)) != 0)
	return (error);

	zfs_init_vattr(vap, lr->lr_mask, lr->lr_mode,
	lr->lr_uid, lr->lr_gid, 0, lr->lr_foid);

	vap->va_size = lr->lr_size;
	ZFS_TIME_DECODE(&vap->va_atime, lr->lr_atime);
	ZFS_TIME_DECODE(&vap->va_mtime, lr->lr_mtime);
	gethrestime(&vap->va_ctime);
	vap->va_mask \|= ATTR_CTIME;

	/*
	* Fill in xvattr_t portions if necessary.
	*/

	start = (lr_setattr_t *)(lr + 1);
	if (vap->va_mask & ATTR_XVATTR) {
	zfs_replay_xvattr((lr_attr_t *)start, &xva);
	start = (caddr_t)start +
	ZIL_XVAT_SIZE(((lr_attr_t *)start)->lr_attr_masksize);
	} else
	xva.xva_vattr.va_mask &= ~ATTR_XVATTR;

	zfsvfs->z_fuid_replay = zfs_replay_fuid_domain(start, &start,
	lr->lr_uid, lr->lr_gid);

	error = zfs_setattr(zp, vap, 0, kcred);

	zfs_fuid_info_free(zfsvfs->z_fuid_replay);
	zfsvfs->z_fuid_replay = NULL;
	zrele(zp);

	return (error);
	}

	static int
	zfs_replay_acl_v0(void arg1, void arg2, boolean_t byteswap)
	{
	zfsvfs_t *zfsvfs = arg1;
	lr_acl_v0_t *lr = arg2;
	ace_t ace = (ace_t )(lr + 1); /* ace array follows lr_acl_t */
	vsecattr_t vsa;
	znode_t *zp;
	int error;

	if (byteswap) {
	byteswap_uint64_array(lr, sizeof (*lr));
	zfs_oldace_byteswap(ace, lr->lr_aclcnt);
	}

	if ((error = zfs_zget(zfsvfs, lr->lr_foid, &zp)) != 0)
	return (error);

	bzero(&vsa, sizeof (vsa));
	vsa.vsa_mask = VSA_ACE \| VSA_ACECNT;
	vsa.vsa_aclcnt = lr->lr_aclcnt;
	vsa.vsa_aclentsz = sizeof (ace_t) * vsa.vsa_aclcnt;
	vsa.vsa_aclflags = 0;
	vsa.vsa_aclentp = ace;

	error = zfs_setsecattr(zp, &vsa, 0, kcred);

	zrele(zp);

	return (error);
	}

	/*
	* Replaying ACLs is complicated by FUID support.
	* The log record may contain some optional data
	* to be used for replaying FUID's. These pieces
	* are the actual FUIDs that were created initially.
	* The FUID table index may no longer be valid and
	* during zfs_create() a new index may be assigned.
	* Because of this the log will contain the original
	* domain+rid in order to create a new FUID.
	*
	* The individual ACEs may contain an ephemeral uid/gid which is no
	* longer valid and will need to be replaced with an actual FUID.
	*
	*/
	static int
	zfs_replay_acl(void arg1, void arg2, boolean_t byteswap)
	{
	zfsvfs_t *zfsvfs = arg1;
	lr_acl_t *lr = arg2;
	ace_t ace = (ace_t )(lr + 1);
	vsecattr_t vsa;
	znode_t *zp;
	int error;

	if (byteswap) {
	byteswap_uint64_array(lr, sizeof (*lr));
	zfs_ace_byteswap(ace, lr->lr_acl_bytes, B_FALSE);
	if (lr->lr_fuidcnt) {
	byteswap_uint64_array((caddr_t)ace +
	ZIL_ACE_LENGTH(lr->lr_acl_bytes),
	lr->lr_fuidcnt * sizeof (uint64_t));
	}
	}

	if ((error = zfs_zget(zfsvfs, lr->lr_foid, &zp)) != 0)
	return (error);

	bzero(&vsa, sizeof (vsa));
	vsa.vsa_mask = VSA_ACE \| VSA_ACECNT \| VSA_ACE_ACLFLAGS;
	vsa.vsa_aclcnt = lr->lr_aclcnt;
	vsa.vsa_aclentp = ace;
	vsa.vsa_aclentsz = lr->lr_acl_bytes;
	vsa.vsa_aclflags = lr->lr_acl_flags;

	if (lr->lr_fuidcnt) {
	void *fuidstart = (caddr_t)ace +
	ZIL_ACE_LENGTH(lr->lr_acl_bytes);

	zfsvfs->z_fuid_replay =
	zfs_replay_fuids(fuidstart, &fuidstart,
	lr->lr_fuidcnt, lr->lr_domcnt, 0, 0);
	}

	error = zfs_setsecattr(zp, &vsa, 0, kcred);

	if (zfsvfs->z_fuid_replay)
	zfs_fuid_info_free(zfsvfs->z_fuid_replay);

	zfsvfs->z_fuid_replay = NULL;
	zrele(zp);

	return (error);
	}

	/*
	* Callback vectors for replaying records
	*/
	zil_replay_func_t *zfs_replay_vector[TX_MAX_TYPE] = {
	zfs_replay_error, /* no such type */
	zfs_replay_create, /* TX_CREATE */
	zfs_replay_create, /* TX_MKDIR */
	zfs_replay_create, /* TX_MKXATTR */
	zfs_replay_create, /* TX_SYMLINK */
	zfs_replay_remove, /* TX_REMOVE */
	zfs_replay_remove, /* TX_RMDIR */
	zfs_replay_link, /* TX_LINK */
	zfs_replay_rename, /* TX_RENAME */
	zfs_replay_write, /* TX_WRITE */
	zfs_replay_truncate, /* TX_TRUNCATE */
	zfs_replay_setattr, /* TX_SETATTR */
	zfs_replay_acl_v0, /* TX_ACL_V0 */
	zfs_replay_acl, /* TX_ACL */
	zfs_replay_create_acl, /* TX_CREATE_ACL */
	zfs_replay_create, /* TX_CREATE_ATTR */
	zfs_replay_create_acl, /* TX_CREATE_ACL_ATTR */
	zfs_replay_create_acl, /* TX_MKDIR_ACL */
	zfs_replay_create, /* TX_MKDIR_ATTR */
	zfs_replay_create_acl, /* TX_MKDIR_ACL_ATTR */
	zfs_replay_write2, /* TX_WRITE2 */
	};
	diff --git a/sys/contrib/openzfs/module/zfs/zfs_vnops.c b/sys/contrib/openzfs/module/zfs/zfs_vnops.c
	index 8229bc9a93e5..170e392abe93 100644
	--- a/sys/contrib/openzfs/module/zfs/zfs_vnops.c
	+++ b/sys/contrib/openzfs/module/zfs/zfs_vnops.c
	@@ -1,911 +1,918 @@
	/*
	* 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/uio_impl.h>
	#include <sys/file.h>
	#include <sys/stat.h>
	#include <sys/kmem.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/policy.h>
	#include <sys/zfs_vnops.h>
	#include <sys/zfs_quota.h>
	#include <sys/zfs_vfsops.h>
	#include <sys/zfs_znode.h>


	static ulong_t zfs_fsync_sync_cnt = 4;

	int
	zfs_fsync(znode_t zp, int syncflag, cred_t cr)
	{
	zfsvfs_t *zfsvfs = ZTOZSB(zp);

	(void) tsd_set(zfs_fsyncer_key, (void *)zfs_fsync_sync_cnt);

	if (zfsvfs->z_os->os_sync != ZFS_SYNC_DISABLED) {
	ZFS_ENTER(zfsvfs);
	ZFS_VERIFY_ZP(zp);
	zil_commit(zfsvfs->z_log, zp->z_id);
	ZFS_EXIT(zfsvfs);
	}
	tsd_set(zfs_fsyncer_key, NULL);

	return (0);
	}


	#if defined(SEEK_HOLE) && defined(SEEK_DATA)
	/*
	* Lseek support for finding holes (cmd == SEEK_HOLE) and
	* data (cmd == SEEK_DATA). "off" is an in/out parameter.
	*/
	static int
	zfs_holey_common(znode_t zp, ulong_t cmd, loff_t off)
	{
	+ zfs_locked_range_t *lr;
	uint64_t noff = (uint64_t)off; / new offset */
	uint64_t file_sz;
	int error;
	boolean_t hole;

	file_sz = zp->z_size;
	if (noff >= file_sz) {
	return (SET_ERROR(ENXIO));
	}

	if (cmd == F_SEEK_HOLE)
	hole = B_TRUE;
	else
	hole = B_FALSE;

	+ /* Flush any mmap()'d data to disk */
	+ if (zn_has_cached_data(zp))
	+ zn_flush_cached_data(zp, B_FALSE);
	+
	+ lr = zfs_rangelock_enter(&zp->z_rangelock, 0, file_sz, RL_READER);
	error = dmu_offset_next(ZTOZSB(zp)->z_os, zp->z_id, hole, &noff);
	+ zfs_rangelock_exit(lr);

	if (error == ESRCH)
	return (SET_ERROR(ENXIO));

	- /* file was dirty, so fall back to using generic logic */
	+ /* File was dirty, so fall back to using generic logic */
	if (error == EBUSY) {
	if (hole)
	*off = file_sz;

	return (0);
	}

	/*
	* We could find a hole that begins after the logical end-of-file,
	* because dmu_offset_next() only works on whole blocks. If the
	* EOF falls mid-block, then indicate that the "virtual hole"
	* at the end of the file begins at the logical EOF, rather than
	* at the end of the last block.
	*/
	if (noff > file_sz) {
	ASSERT(hole);
	noff = file_sz;
	}

	if (noff < *off)
	return (error);
	*off = noff;
	return (error);
	}

	int
	zfs_holey(znode_t zp, ulong_t cmd, loff_t off)
	{
	zfsvfs_t *zfsvfs = ZTOZSB(zp);
	int error;

	ZFS_ENTER(zfsvfs);
	ZFS_VERIFY_ZP(zp);

	error = zfs_holey_common(zp, cmd, off);

	ZFS_EXIT(zfsvfs);
	return (error);
	}
	#endif /* SEEK_HOLE && SEEK_DATA */

	/ARGSUSED/
	int
	zfs_access(znode_t zp, int mode, int flag, cred_t cr)
	{
	zfsvfs_t *zfsvfs = ZTOZSB(zp);
	int error;

	ZFS_ENTER(zfsvfs);
	ZFS_VERIFY_ZP(zp);

	if (flag & V_ACE_MASK)
	error = zfs_zaccess(zp, mode, flag, B_FALSE, cr);
	else
	error = zfs_zaccess_rwx(zp, mode, flag, cr);

	ZFS_EXIT(zfsvfs);
	return (error);
	}

	static unsigned long zfs_vnops_read_chunk_size = 1024 * 1024; /* Tunable */

	/*
	* Read bytes from specified file into supplied buffer.
	*
	* IN: zp - inode of file to be read from.
	* uio - structure supplying read location, range info,
	* and return buffer.
	* ioflag - O_SYNC flags; used to provide FRSYNC semantics.
	* O_DIRECT flag; used to bypass page cache.
	* cr - credentials of caller.
	*
	* OUT: uio - updated offset and range, buffer filled.
	*
	* RETURN: 0 on success, error code on failure.
	*
	* Side Effects:
	* inode - atime updated if byte count > 0
	*/
	/* ARGSUSED */
	int
	zfs_read(struct znode zp, zfs_uio_t uio, int ioflag, cred_t *cr)
	{
	int error = 0;
	boolean_t frsync = B_FALSE;

	zfsvfs_t *zfsvfs = ZTOZSB(zp);
	ZFS_ENTER(zfsvfs);
	ZFS_VERIFY_ZP(zp);

	if (zp->z_pflags & ZFS_AV_QUARANTINED) {
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(EACCES));
	}

	/* We don't copy out anything useful for directories. */
	if (Z_ISDIR(ZTOTYPE(zp))) {
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(EISDIR));
	}

	/*
	* Validate file offset
	*/
	if (zfs_uio_offset(uio) < (offset_t)0) {
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(EINVAL));
	}

	/*
	* Fasttrack empty reads
	*/
	if (zfs_uio_resid(uio) == 0) {
	ZFS_EXIT(zfsvfs);
	return (0);
	}

	#ifdef FRSYNC
	/*
	* If we're in FRSYNC mode, sync out this znode before reading it.
	* Only do this for non-snapshots.
	*
	* Some platforms do not support FRSYNC and instead map it
	* to O_SYNC, which results in unnecessary calls to zil_commit. We
	* only honor FRSYNC requests on platforms which support it.
	*/
	frsync = !!(ioflag & FRSYNC);
	#endif
	if (zfsvfs->z_log &&
	(frsync \|\| zfsvfs->z_os->os_sync == ZFS_SYNC_ALWAYS))
	zil_commit(zfsvfs->z_log, zp->z_id);

	/*
	* Lock the range against changes.
	*/
	zfs_locked_range_t *lr = zfs_rangelock_enter(&zp->z_rangelock,
	zfs_uio_offset(uio), zfs_uio_resid(uio), RL_READER);

	/*
	* If we are reading past end-of-file we can skip
	* to the end; but we might still need to set atime.
	*/
	if (zfs_uio_offset(uio) >= zp->z_size) {
	error = 0;
	goto out;
	}

	ASSERT(zfs_uio_offset(uio) < zp->z_size);
	ssize_t n = MIN(zfs_uio_resid(uio), zp->z_size - zfs_uio_offset(uio));
	ssize_t start_resid = n;

	while (n > 0) {
	ssize_t nbytes = MIN(n, zfs_vnops_read_chunk_size -
	P2PHASE(zfs_uio_offset(uio), zfs_vnops_read_chunk_size));
	#ifdef UIO_NOCOPY
	if (zfs_uio_segflg(uio) == UIO_NOCOPY)
	error = mappedread_sf(zp, nbytes, uio);
	else
	#endif
	if (zn_has_cached_data(zp) && !(ioflag & O_DIRECT)) {
	error = mappedread(zp, nbytes, uio);
	} else {
	error = dmu_read_uio_dbuf(sa_get_db(zp->z_sa_hdl),
	uio, nbytes);
	}

	if (error) {
	/* convert checksum errors into IO errors */
	if (error == ECKSUM)
	error = SET_ERROR(EIO);
	break;
	}

	n -= nbytes;
	}

	int64_t nread = start_resid - n;
	dataset_kstats_update_read_kstats(&zfsvfs->z_kstat, nread);
	task_io_account_read(nread);
	out:
	zfs_rangelock_exit(lr);

	ZFS_ACCESSTIME_STAMP(zfsvfs, zp);
	ZFS_EXIT(zfsvfs);
	return (error);
	}

	/*
	* Write the bytes to a file.
	*
	* IN: zp - znode of file to be written to.
	* uio - structure supplying write location, range info,
	* and data buffer.
	* ioflag - O_APPEND flag set if in append mode.
	* O_DIRECT flag; used to bypass page cache.
	* cr - credentials of caller.
	*
	* OUT: uio - updated offset and range.
	*
	* RETURN: 0 if success
	* error code if failure
	*
	* Timestamps:
	* ip - ctime\|mtime updated if byte count > 0
	*/

	/* ARGSUSED */
	int
	zfs_write(znode_t zp, zfs_uio_t uio, int ioflag, cred_t *cr)
	{
	int error = 0;
	ssize_t start_resid = zfs_uio_resid(uio);

	/*
	* Fasttrack empty write
	*/
	ssize_t n = start_resid;
	if (n == 0)
	return (0);

	zfsvfs_t *zfsvfs = ZTOZSB(zp);
	ZFS_ENTER(zfsvfs);
	ZFS_VERIFY_ZP(zp);

	sa_bulk_attr_t bulk[4];
	int count = 0;
	uint64_t mtime[2], ctime[2];
	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_SIZE(zfsvfs), NULL,
	&zp->z_size, 8);
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_FLAGS(zfsvfs), NULL,
	&zp->z_pflags, 8);

	/*
	* 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 immutable or not appending then return EPERM.
	* Intentionally allow ZFS_READONLY through here.
	* See zfs_zaccess_common()
	*/
	if ((zp->z_pflags & ZFS_IMMUTABLE) \|\|
	((zp->z_pflags & ZFS_APPENDONLY) && !(ioflag & O_APPEND) &&
	(zfs_uio_offset(uio) < zp->z_size))) {
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(EPERM));
	}

	/*
	* Validate file offset
	*/
	offset_t woff = ioflag & O_APPEND ? zp->z_size : zfs_uio_offset(uio);
	if (woff < 0) {
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(EINVAL));
	}

	const uint64_t max_blksz = zfsvfs->z_max_blksz;

	/*
	* Pre-fault the pages to ensure slow (eg NFS) pages
	* don't hold up txg.
	* Skip this if uio contains loaned arc_buf.
	*/
	if (zfs_uio_prefaultpages(MIN(n, max_blksz), uio)) {
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(EFAULT));
	}

	/*
	* If in append mode, set the io offset pointer to eof.
	*/
	zfs_locked_range_t *lr;
	if (ioflag & O_APPEND) {
	/*
	* Obtain an appending range lock to guarantee file append
	* semantics. We reset the write offset once we have the lock.
	*/
	lr = zfs_rangelock_enter(&zp->z_rangelock, 0, n, RL_APPEND);
	woff = lr->lr_offset;
	if (lr->lr_length == UINT64_MAX) {
	/*
	* We overlocked the file because this write will cause
	* the file block size to increase.
	* Note that zp_size cannot change with this lock held.
	*/
	woff = zp->z_size;
	}
	zfs_uio_setoffset(uio, woff);
	} else {
	/*
	* Note that if the file block size will change as a result of
	* this write, then this range lock will lock the entire file
	* so that we can re-write the block safely.
	*/
	lr = zfs_rangelock_enter(&zp->z_rangelock, woff, n, RL_WRITER);
	}

	if (zn_rlimit_fsize(zp, uio)) {
	zfs_rangelock_exit(lr);
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(EFBIG));
	}

	const rlim64_t limit = MAXOFFSET_T;

	if (woff >= limit) {
	zfs_rangelock_exit(lr);
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(EFBIG));
	}

	if (n > limit - woff)
	n = limit - woff;

	uint64_t end_size = MAX(zp->z_size, woff + n);
	zilog_t *zilog = zfsvfs->z_log;

	const uint64_t uid = KUID_TO_SUID(ZTOUID(zp));
	const uint64_t gid = KGID_TO_SGID(ZTOGID(zp));
	const uint64_t projid = zp->z_projid;

	/*
	* Write the file in reasonable size chunks. Each chunk is written
	* in a separate transaction; this keeps the intent log records small
	* and allows us to do more fine-grained space accounting.
	*/
	while (n > 0) {
	woff = zfs_uio_offset(uio);

	if (zfs_id_overblockquota(zfsvfs, DMU_USERUSED_OBJECT, uid) \|\|
	zfs_id_overblockquota(zfsvfs, DMU_GROUPUSED_OBJECT, gid) \|\|
	(projid != ZFS_DEFAULT_PROJID &&
	zfs_id_overblockquota(zfsvfs, DMU_PROJECTUSED_OBJECT,
	projid))) {
	error = SET_ERROR(EDQUOT);
	break;
	}

	arc_buf_t *abuf = NULL;
	if (n >= max_blksz && woff >= zp->z_size &&
	P2PHASE(woff, max_blksz) == 0 &&
	zp->z_blksz == max_blksz) {
	/*
	* This write covers a full block. "Borrow" a buffer
	* from the dmu so that we can fill it before we enter
	* a transaction. This avoids the possibility of
	* holding up the transaction if the data copy hangs
	* up on a pagefault (e.g., from an NFS server mapping).
	*/
	size_t cbytes;

	abuf = dmu_request_arcbuf(sa_get_db(zp->z_sa_hdl),
	max_blksz);
	ASSERT(abuf != NULL);
	ASSERT(arc_buf_size(abuf) == max_blksz);
	if ((error = zfs_uiocopy(abuf->b_data, max_blksz,
	UIO_WRITE, uio, &cbytes))) {
	dmu_return_arcbuf(abuf);
	break;
	}
	ASSERT3S(cbytes, ==, max_blksz);
	}

	/*
	* Start a transaction.
	*/
	dmu_tx_t *tx = dmu_tx_create(zfsvfs->z_os);
	dmu_tx_hold_sa(tx, zp->z_sa_hdl, B_FALSE);
	dmu_buf_impl_t db = (dmu_buf_impl_t )sa_get_db(zp->z_sa_hdl);
	DB_DNODE_ENTER(db);
	dmu_tx_hold_write_by_dnode(tx, DB_DNODE(db), woff,
	MIN(n, max_blksz));
	DB_DNODE_EXIT(db);
	zfs_sa_upgrade_txholds(tx, zp);
	error = dmu_tx_assign(tx, TXG_WAIT);
	if (error) {
	dmu_tx_abort(tx);
	if (abuf != NULL)
	dmu_return_arcbuf(abuf);
	break;
	}

	/*
	* If rangelock_enter() over-locked we grow the blocksize
	* and then reduce the lock range. This will only happen
	* on the first iteration since rangelock_reduce() will
	* shrink down lr_length to the appropriate size.
	*/
	if (lr->lr_length == UINT64_MAX) {
	uint64_t new_blksz;

	if (zp->z_blksz > 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));
	new_blksz = MIN(end_size,
	1 << highbit64(zp->z_blksz));
	} else {
	new_blksz = MIN(end_size, max_blksz);
	}
	zfs_grow_blocksize(zp, new_blksz, tx);
	zfs_rangelock_reduce(lr, woff, n);
	}

	/*
	* XXX - should we really limit each write to z_max_blksz?
	* Perhaps we should use SPA_MAXBLOCKSIZE chunks?
	*/
	const ssize_t nbytes =
	MIN(n, max_blksz - P2PHASE(woff, max_blksz));

	ssize_t tx_bytes;
	if (abuf == NULL) {
	tx_bytes = zfs_uio_resid(uio);
	zfs_uio_fault_disable(uio, B_TRUE);
	error = dmu_write_uio_dbuf(sa_get_db(zp->z_sa_hdl),
	uio, nbytes, tx);
	zfs_uio_fault_disable(uio, B_FALSE);
	#ifdef __linux__
	if (error == EFAULT) {
	dmu_tx_commit(tx);
	/*
	* Account for partial writes before
	* continuing the loop.
	* Update needs to occur before the next
	* zfs_uio_prefaultpages, or prefaultpages may
	* error, and we may break the loop early.
	*/
	if (tx_bytes != zfs_uio_resid(uio))
	n -= tx_bytes - zfs_uio_resid(uio);
	if (zfs_uio_prefaultpages(MIN(n, max_blksz),
	uio)) {
	break;
	}
	continue;
	}
	#endif
	if (error != 0) {
	dmu_tx_commit(tx);
	break;
	}
	tx_bytes -= zfs_uio_resid(uio);
	} else {
	/* Implied by abuf != NULL: */
	ASSERT3S(n, >=, max_blksz);
	ASSERT0(P2PHASE(woff, max_blksz));
	/*
	* We can simplify nbytes to MIN(n, max_blksz) since
	* P2PHASE(woff, max_blksz) is 0, and knowing
	* n >= max_blksz lets us simplify further:
	*/
	ASSERT3S(nbytes, ==, max_blksz);
	/*
	* Thus, we're writing a full block at a block-aligned
	* offset and extending the file past EOF.
	*
	* dmu_assign_arcbuf_by_dbuf() will directly assign the
	* arc buffer to a dbuf.
	*/
	error = dmu_assign_arcbuf_by_dbuf(
	sa_get_db(zp->z_sa_hdl), woff, abuf, tx);
	if (error != 0) {
	dmu_return_arcbuf(abuf);
	dmu_tx_commit(tx);
	break;
	}
	ASSERT3S(nbytes, <=, zfs_uio_resid(uio));
	zfs_uioskip(uio, nbytes);
	tx_bytes = nbytes;
	}
	if (tx_bytes && zn_has_cached_data(zp) &&
	!(ioflag & O_DIRECT)) {
	update_pages(zp, woff, tx_bytes, zfsvfs->z_os);
	}

	/*
	* If we made no progress, we're done. If we made even
	* partial progress, update the znode and ZIL accordingly.
	*/
	if (tx_bytes == 0) {
	(void) sa_update(zp->z_sa_hdl, SA_ZPL_SIZE(zfsvfs),
	(void *)&zp->z_size, sizeof (uint64_t), tx);
	dmu_tx_commit(tx);
	ASSERT(error != 0);
	break;
	}

	/*
	* Clear Set-UID/Set-GID bits on successful write if not
	* privileged and at least one of the execute bits is set.
	*
	* It would be nice to do this after all writes have
	* been done, but that would still expose the ISUID/ISGID
	* to another app after the partial write is committed.
	*
	* Note: we don't call zfs_fuid_map_id() here because
	* user 0 is not an ephemeral uid.
	*/
	mutex_enter(&zp->z_acl_lock);
	if ((zp->z_mode & (S_IXUSR \| (S_IXUSR >> 3) \|
	(S_IXUSR >> 6))) != 0 &&
	(zp->z_mode & (S_ISUID \| S_ISGID)) != 0 &&
	secpolicy_vnode_setid_retain(zp, cr,
	((zp->z_mode & S_ISUID) != 0 && uid == 0)) != 0) {
	uint64_t newmode;
	zp->z_mode &= ~(S_ISUID \| S_ISGID);
	newmode = zp->z_mode;
	(void) sa_update(zp->z_sa_hdl, SA_ZPL_MODE(zfsvfs),
	(void *)&newmode, sizeof (uint64_t), tx);
	}
	mutex_exit(&zp->z_acl_lock);

	zfs_tstamp_update_setup(zp, CONTENT_MODIFIED, mtime, ctime);

	/*
	* Update the file size (zp_size) if it has changed;
	* account for possible concurrent updates.
	*/
	while ((end_size = zp->z_size) < zfs_uio_offset(uio)) {
	(void) atomic_cas_64(&zp->z_size, end_size,
	zfs_uio_offset(uio));
	ASSERT(error == 0);
	}
	/*
	* If we are replaying and eof is non zero then force
	* the file size to the specified eof. Note, there's no
	* concurrency during replay.
	*/
	if (zfsvfs->z_replay && zfsvfs->z_replay_eof != 0)
	zp->z_size = zfsvfs->z_replay_eof;

	error = sa_bulk_update(zp->z_sa_hdl, bulk, count, tx);

	zfs_log_write(zilog, tx, TX_WRITE, zp, woff, tx_bytes, ioflag,
	NULL, NULL);
	dmu_tx_commit(tx);

	if (error != 0)
	break;
	ASSERT3S(tx_bytes, ==, nbytes);
	n -= nbytes;

	if (n > 0) {
	if (zfs_uio_prefaultpages(MIN(n, max_blksz), uio)) {
	error = SET_ERROR(EFAULT);
	break;
	}
	}
	}

	zfs_znode_update_vfs(zp);
	zfs_rangelock_exit(lr);

	/*
	* If we're in replay mode, or we made no progress, or the
	* uio data is inaccessible return an error. Otherwise, it's
	* at least a partial write, so it's successful.
	*/
	if (zfsvfs->z_replay \|\| zfs_uio_resid(uio) == start_resid \|\|
	error == EFAULT) {
	ZFS_EXIT(zfsvfs);
	return (error);
	}

	if (ioflag & (O_SYNC \| O_DSYNC) \|\|
	zfsvfs->z_os->os_sync == ZFS_SYNC_ALWAYS)
	zil_commit(zilog, zp->z_id);

	const int64_t nwritten = start_resid - zfs_uio_resid(uio);
	dataset_kstats_update_write_kstats(&zfsvfs->z_kstat, nwritten);
	task_io_account_write(nwritten);

	ZFS_EXIT(zfsvfs);
	return (0);
	}

	/ARGSUSED/
	int
	zfs_getsecattr(znode_t zp, vsecattr_t vsecp, int flag, cred_t *cr)
	{
	zfsvfs_t *zfsvfs = ZTOZSB(zp);
	int error;
	boolean_t skipaclchk = (flag & ATTR_NOACLCHECK) ? B_TRUE : B_FALSE;

	ZFS_ENTER(zfsvfs);
	ZFS_VERIFY_ZP(zp);
	error = zfs_getacl(zp, vsecp, skipaclchk, cr);
	ZFS_EXIT(zfsvfs);

	return (error);
	}

	/ARGSUSED/
	int
	zfs_setsecattr(znode_t zp, vsecattr_t vsecp, int flag, cred_t *cr)
	{
	zfsvfs_t *zfsvfs = ZTOZSB(zp);
	int error;
	boolean_t skipaclchk = (flag & ATTR_NOACLCHECK) ? B_TRUE : B_FALSE;
	zilog_t *zilog = zfsvfs->z_log;

	ZFS_ENTER(zfsvfs);
	ZFS_VERIFY_ZP(zp);

	error = zfs_setacl(zp, vsecp, skipaclchk, cr);

	if (zfsvfs->z_os->os_sync == ZFS_SYNC_ALWAYS)
	zil_commit(zilog, 0);

	ZFS_EXIT(zfsvfs);
	return (error);
	}

	#ifdef ZFS_DEBUG
	static int zil_fault_io = 0;
	#endif

	static void zfs_get_done(zgd_t *zgd, int error);

	/*
	* Get data to generate a TX_WRITE intent log record.
	*/
	int
	zfs_get_data(void arg, uint64_t gen, lr_write_t lr, char *buf,
	struct lwb lwb, zio_t zio)
	{
	zfsvfs_t *zfsvfs = arg;
	objset_t *os = zfsvfs->z_os;
	znode_t *zp;
	uint64_t object = lr->lr_foid;
	uint64_t offset = lr->lr_offset;
	uint64_t size = lr->lr_length;
	dmu_buf_t *db;
	zgd_t *zgd;
	int error = 0;
	uint64_t zp_gen;

	ASSERT3P(lwb, !=, NULL);
	ASSERT3P(zio, !=, NULL);
	ASSERT3U(size, !=, 0);

	/*
	* Nothing to do if the file has been removed
	*/
	if (zfs_zget(zfsvfs, object, &zp) != 0)
	return (SET_ERROR(ENOENT));
	if (zp->z_unlinked) {
	/*
	* Release the vnode asynchronously as we currently have the
	* txg stopped from syncing.
	*/
	zfs_zrele_async(zp);
	return (SET_ERROR(ENOENT));
	}
	/* check if generation number matches */
	if (sa_lookup(zp->z_sa_hdl, SA_ZPL_GEN(zfsvfs), &zp_gen,
	sizeof (zp_gen)) != 0) {
	zfs_zrele_async(zp);
	return (SET_ERROR(EIO));
	}
	if (zp_gen != gen) {
	zfs_zrele_async(zp);
	return (SET_ERROR(ENOENT));
	}

	zgd = (zgd_t *)kmem_zalloc(sizeof (zgd_t), KM_SLEEP);
	zgd->zgd_lwb = lwb;
	zgd->zgd_private = zp;

	/*
	* Write records come in two flavors: immediate and indirect.
	* For small writes it's cheaper to store the data with the
	* log record (immediate); for large writes it's cheaper to
	* sync the data and get a pointer to it (indirect) so that
	* we don't have to write the data twice.
	*/
	if (buf != NULL) { /* immediate write */
	zgd->zgd_lr = zfs_rangelock_enter(&zp->z_rangelock,
	offset, size, RL_READER);
	/* test for truncation needs to be done while range locked */
	if (offset >= zp->z_size) {
	error = SET_ERROR(ENOENT);
	} else {
	error = dmu_read(os, object, offset, size, buf,
	DMU_READ_NO_PREFETCH);
	}
	ASSERT(error == 0 \|\| error == ENOENT);
	} else { /* indirect write */
	/*
	* Have to lock the whole block to ensure when it's
	* written out and its checksum is being calculated
	* that no one can change the data. We need to re-check
	* blocksize after we get the lock in case it's changed!
	*/
	for (;;) {
	uint64_t blkoff;
	size = zp->z_blksz;
	blkoff = ISP2(size) ? P2PHASE(offset, size) : offset;
	offset -= blkoff;
	zgd->zgd_lr = zfs_rangelock_enter(&zp->z_rangelock,
	offset, size, RL_READER);
	if (zp->z_blksz == size)
	break;
	offset += blkoff;
	zfs_rangelock_exit(zgd->zgd_lr);
	}
	/* test for truncation needs to be done while range locked */
	if (lr->lr_offset >= zp->z_size)
	error = SET_ERROR(ENOENT);
	#ifdef ZFS_DEBUG
	if (zil_fault_io) {
	error = SET_ERROR(EIO);
	zil_fault_io = 0;
	}
	#endif
	if (error == 0)
	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;

	ASSERT(db->db_offset == offset);
	ASSERT(db->db_size == size);

	error = dmu_sync(zio, lr->lr_common.lrc_txg,
	zfs_get_done, zgd);
	ASSERT(error \|\| lr->lr_length <= size);

	/*
	* On success, we need to wait for the write I/O
	* initiated by dmu_sync() to complete before we can
	* release this dbuf. We will finish everything up
	* in the zfs_get_done() callback.
	*/
	if (error == 0)
	return (0);

	if (error == EALREADY) {
	lr->lr_common.lrc_txtype = TX_WRITE2;
	/*
	* TX_WRITE2 relies on the data previously
	* written by the TX_WRITE that caused
	* EALREADY. We zero out the BP because
	* it is the old, currently-on-disk BP.
	*/
	zgd->zgd_bp = NULL;
	BP_ZERO(bp);
	error = 0;
	}
	}
	}

	zfs_get_done(zgd, error);

	return (error);
	}


	/* ARGSUSED */
	static void
	zfs_get_done(zgd_t *zgd, int error)
	{
	znode_t *zp = zgd->zgd_private;

	if (zgd->zgd_db)
	dmu_buf_rele(zgd->zgd_db, zgd);

	zfs_rangelock_exit(zgd->zgd_lr);

	/*
	* Release the vnode asynchronously as we currently have the
	* txg stopped from syncing.
	*/
	zfs_zrele_async(zp);

	kmem_free(zgd, sizeof (zgd_t));
	}

	EXPORT_SYMBOL(zfs_access);
	EXPORT_SYMBOL(zfs_fsync);
	EXPORT_SYMBOL(zfs_holey);
	EXPORT_SYMBOL(zfs_read);
	EXPORT_SYMBOL(zfs_write);
	EXPORT_SYMBOL(zfs_getsecattr);
	EXPORT_SYMBOL(zfs_setsecattr);

	ZFS_MODULE_PARAM(zfs_vnops, zfs_vnops_, read_chunk_size, ULONG, ZMOD_RW,
	"Bytes to read per chunk");
	diff --git a/sys/contrib/openzfs/module/zfs/zio_compress.c b/sys/contrib/openzfs/module/zfs/zio_compress.c
	index 33602bd471f3..1ff1e76d7f22 100644
	--- a/sys/contrib/openzfs/module/zfs/zio_compress.c
	+++ b/sys/contrib/openzfs/module/zfs/zio_compress.c
	@@ -1,220 +1,220 @@
	/*
	* 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 by Saso Kiselkov. All rights reserved.
	*/

	/*
	* Copyright (c) 2013, 2018 by Delphix. All rights reserved.
	* Copyright (c) 2019, Klara Inc.
	* Copyright (c) 2019, Allan Jude
	*/

	#include <sys/zfs_context.h>
	#include <sys/spa.h>
	#include <sys/zfeature.h>
	#include <sys/zio.h>
	#include <sys/zio_compress.h>
	#include <sys/zstd/zstd.h>

	/*
	* If nonzero, every 1/X decompression attempts will fail, simulating
	* an undetected memory error.
	*/
	unsigned long zio_decompress_fail_fraction = 0;

	/*
	* Compression vectors.
	*/
	zio_compress_info_t zio_compress_table[ZIO_COMPRESS_FUNCTIONS] = {
	{"inherit", 0, NULL, NULL, NULL},
	{"on", 0, NULL, NULL, NULL},
	{"uncompressed", 0, NULL, NULL, NULL},
	{"lzjb", 0, lzjb_compress, lzjb_decompress, NULL},
	{"empty", 0, NULL, NULL, NULL},
	{"gzip-1", 1, gzip_compress, gzip_decompress, NULL},
	{"gzip-2", 2, gzip_compress, gzip_decompress, NULL},
	{"gzip-3", 3, gzip_compress, gzip_decompress, NULL},
	{"gzip-4", 4, gzip_compress, gzip_decompress, NULL},
	{"gzip-5", 5, gzip_compress, gzip_decompress, NULL},
	{"gzip-6", 6, gzip_compress, gzip_decompress, NULL},
	{"gzip-7", 7, gzip_compress, gzip_decompress, NULL},
	{"gzip-8", 8, gzip_compress, gzip_decompress, NULL},
	{"gzip-9", 9, gzip_compress, gzip_decompress, NULL},
	{"zle", 64, zle_compress, zle_decompress, NULL},
	{"lz4", 0, lz4_compress_zfs, lz4_decompress_zfs, NULL},
	{"zstd", ZIO_ZSTD_LEVEL_DEFAULT, zfs_zstd_compress,
	zfs_zstd_decompress, zfs_zstd_decompress_level},
	};

	uint8_t
	zio_complevel_select(spa_t *spa, enum zio_compress compress, uint8_t child,
	uint8_t parent)
	{
	uint8_t result;

	if (!ZIO_COMPRESS_HASLEVEL(compress))
	return (0);

	result = child;
	if (result == ZIO_COMPLEVEL_INHERIT)
	result = parent;

	return (result);
	}

	enum zio_compress
	zio_compress_select(spa_t *spa, enum zio_compress child,
	enum zio_compress parent)
	{
	enum zio_compress result;

	ASSERT(child < ZIO_COMPRESS_FUNCTIONS);
	ASSERT(parent < ZIO_COMPRESS_FUNCTIONS);
	ASSERT(parent != ZIO_COMPRESS_INHERIT);

	result = child;
	if (result == ZIO_COMPRESS_INHERIT)
	result = parent;

	if (result == ZIO_COMPRESS_ON) {
	if (spa_feature_is_active(spa, SPA_FEATURE_LZ4_COMPRESS))
	result = ZIO_COMPRESS_LZ4_ON_VALUE;
	else
	result = ZIO_COMPRESS_LEGACY_ON_VALUE;
	}

	return (result);
	}

	/ARGSUSED/
	static int
	zio_compress_zeroed_cb(void data, size_t len, void private)
	{
	uint64_t end = (uint64_t )((char *)data + len);
	for (uint64_t word = (uint64_t )data; word < end; word++)
	if (*word != 0)
	return (1);

	return (0);
	}

	size_t
	zio_compress_data(enum zio_compress c, abd_t src, void dst, size_t s_len,
	uint8_t level)
	{
	size_t c_len, d_len;
	uint8_t complevel;
	zio_compress_info_t *ci = &zio_compress_table[c];

	ASSERT((uint_t)c < ZIO_COMPRESS_FUNCTIONS);
	ASSERT((uint_t)c == ZIO_COMPRESS_EMPTY \|\| ci->ci_compress != NULL);

	/*
	* If the data is all zeroes, we don't even need to allocate
	* a block for it. We indicate this by returning zero size.
	*/
	if (abd_iterate_func(src, 0, s_len, zio_compress_zeroed_cb, NULL) == 0)
	return (0);

	if (c == ZIO_COMPRESS_EMPTY)
	return (s_len);

	/* Compress at least 12.5% */
	d_len = s_len - (s_len >> 3);

	complevel = ci->ci_level;

	if (c == ZIO_COMPRESS_ZSTD) {
	/* If we don't know the level, we can't compress it */
	if (level == ZIO_COMPLEVEL_INHERIT)
	return (s_len);

	if (level == ZIO_COMPLEVEL_DEFAULT)
	complevel = ZIO_ZSTD_LEVEL_DEFAULT;
	else
	complevel = level;

	ASSERT3U(complevel, !=, ZIO_COMPLEVEL_INHERIT);
	}

	/* No compression algorithms can read from ABDs directly */
	void *tmp = abd_borrow_buf_copy(src, s_len);
	c_len = ci->ci_compress(tmp, dst, s_len, d_len, complevel);
	abd_return_buf(src, tmp, s_len);

	if (c_len > d_len)
	return (s_len);

	ASSERT3U(c_len, <=, d_len);
	return (c_len);
	}

	int
	zio_decompress_data_buf(enum zio_compress c, void src, void dst,
	size_t s_len, size_t d_len, uint8_t *level)
	{
	zio_compress_info_t *ci = &zio_compress_table[c];
	if ((uint_t)c >= ZIO_COMPRESS_FUNCTIONS \|\| ci->ci_decompress == NULL)
	return (SET_ERROR(EINVAL));

	if (ci->ci_decompress_level != NULL && level != NULL)
	return (ci->ci_decompress_level(src, dst, s_len, d_len, level));

	return (ci->ci_decompress(src, dst, s_len, d_len, ci->ci_level));
	}

	int
	zio_decompress_data(enum zio_compress c, abd_t src, void dst,
	size_t s_len, size_t d_len, uint8_t *level)
	{
	void *tmp = abd_borrow_buf_copy(src, s_len);
	int ret = zio_decompress_data_buf(c, tmp, dst, s_len, d_len, level);
	abd_return_buf(src, tmp, s_len);

	/*
	* Decompression shouldn't fail, because we've already verified
	* the checksum. However, for extra protection (e.g. against bitflips
	* in non-ECC RAM), we handle this error (and test it).
	*/
	if (zio_decompress_fail_fraction != 0 &&
	random_in_range(zio_decompress_fail_fraction) == 0)
	ret = SET_ERROR(EINVAL);

	return (ret);
	}

	int
	zio_compress_to_feature(enum zio_compress comp)
	{
	switch (comp) {
	case ZIO_COMPRESS_ZSTD:
	return (SPA_FEATURE_ZSTD_COMPRESS);
	default:
	- /* fallthru */;
	+ break;
	}
	return (SPA_FEATURE_NONE);
	}
	diff --git a/sys/contrib/openzfs/module/zfs/zvol.c b/sys/contrib/openzfs/module/zfs/zvol.c
	index 88450aabb469..721a7b4b878e 100644
	--- a/sys/contrib/openzfs/module/zfs/zvol.c
	+++ b/sys/contrib/openzfs/module/zfs/zvol.c
	@@ -1,1754 +1,1790 @@
	/*
	* 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 Lawrence Livermore National Security, LLC.
	* Produced at Lawrence Livermore National Laboratory (cf, DISCLAIMER).
	* Rewritten for Linux by Brian Behlendorf <behlendorf1@llnl.gov>.
	* LLNL-CODE-403049.
	*
	* 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/<pool_name>/<dataset_name>
	*
	* Volumes are persistent through reboot and module load. No user command
	* needs to be run before opening and using a device.
	*
	* Copyright 2014 Nexenta Systems, Inc. All rights reserved.
	* Copyright (c) 2016 Actifio, Inc. All rights reserved.
	* Copyright (c) 2012, 2019 by Delphix. All rights reserved.
	*/

	/*
	* Note on locking of zvol state structures.
	*
	* These structures are used to maintain internal state used to emulate block
	* devices on top of zvols. In particular, management of device minor number
	* operations - create, remove, rename, and set_snapdev - involves access to
	* these structures. The zvol_state_lock is primarily used to protect the
	* zvol_state_list. The zv->zv_state_lock is used to protect the contents
	* of the zvol_state_t structures, as well as to make sure that when the
	* time comes to remove the structure from the list, it is not in use, and
	* therefore, it can be taken off zvol_state_list and freed.
	*
	* The zv_suspend_lock was introduced to allow for suspending I/O to a zvol,
	* e.g. for the duration of receive and rollback operations. This lock can be
	* held for significant periods of time. Given that it is undesirable to hold
	* mutexes for long periods of time, the following lock ordering applies:
	* - take zvol_state_lock if necessary, to protect zvol_state_list
	* - take zv_suspend_lock if necessary, by the code path in question
	* - take zv_state_lock to protect zvol_state_t
	*
	* The minor operations are issued to spa->spa_zvol_taskq queues, that are
	* single-threaded (to preserve order of minor operations), and are executed
	* through the zvol_task_cb that dispatches the specific operations. Therefore,
	* these operations are serialized per pool. Consequently, we can be certain
	* that for a given zvol, there is only one operation at a time in progress.
	* That is why one can be sure that first, zvol_state_t for a given zvol is
	* allocated and placed on zvol_state_list, and then other minor operations
	* for this zvol are going to proceed in the order of issue.
	*
	*/

	#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>


	unsigned int zvol_inhibit_dev = 0;
	unsigned int zvol_volmode = ZFS_VOLMODE_GEOM;

	struct hlist_head *zvol_htable;
	list_t zvol_state_list;
	krwlock_t zvol_state_lock;
	const zvol_platform_ops_t *ops;

	typedef enum {
	ZVOL_ASYNC_REMOVE_MINORS,
	ZVOL_ASYNC_RENAME_MINORS,
	ZVOL_ASYNC_SET_SNAPDEV,
	ZVOL_ASYNC_SET_VOLMODE,
	ZVOL_ASYNC_MAX
	} zvol_async_op_t;

	typedef struct {
	zvol_async_op_t op;
	char name1[MAXNAMELEN];
	char name2[MAXNAMELEN];
	uint64_t value;
	} zvol_task_t;

	uint64_t
	zvol_name_hash(const char *name)
	{
	int i;
	uint64_t crc = -1ULL;
	const uint8_t p = (const uint8_t )name;
	ASSERT(zfs_crc64_table[128] == ZFS_CRC64_POLY);
	for (i = 0; i < MAXNAMELEN - 1 && *p; i++, p++) {
	crc = (crc >> 8) ^ zfs_crc64_table[(crc ^ (*p)) & 0xFF];
	}
	return (crc);
	}

	/*
	* Find a zvol_state_t given the name and hash generated by zvol_name_hash.
	* If found, return with zv_suspend_lock and zv_state_lock taken, otherwise,
	* return (NULL) without the taking locks. The zv_suspend_lock is always taken
	* before zv_state_lock. The mode argument indicates the mode (including none)
	* for zv_suspend_lock to be taken.
	*/
	zvol_state_t *
	zvol_find_by_name_hash(const char *name, uint64_t hash, int mode)
	{
	zvol_state_t *zv;
	struct hlist_node *p = NULL;

	rw_enter(&zvol_state_lock, RW_READER);
	hlist_for_each(p, ZVOL_HT_HEAD(hash)) {
	zv = hlist_entry(p, zvol_state_t, zv_hlink);
	mutex_enter(&zv->zv_state_lock);
	if (zv->zv_hash == hash &&
	strncmp(zv->zv_name, name, MAXNAMELEN) == 0) {
	/*
	* this is the right zvol, take the locks in the
	* right order
	*/
	if (mode != RW_NONE &&
	!rw_tryenter(&zv->zv_suspend_lock, mode)) {
	mutex_exit(&zv->zv_state_lock);
	rw_enter(&zv->zv_suspend_lock, mode);
	mutex_enter(&zv->zv_state_lock);
	/*
	* zvol cannot be renamed as we continue
	* to hold zvol_state_lock
	*/
	ASSERT(zv->zv_hash == hash &&
	strncmp(zv->zv_name, name, MAXNAMELEN)
	== 0);
	}
	rw_exit(&zvol_state_lock);
	return (zv);
	}
	mutex_exit(&zv->zv_state_lock);
	}
	rw_exit(&zvol_state_lock);

	return (NULL);
	}

	/*
	* Find a zvol_state_t given the name.
	* If found, return with zv_suspend_lock and zv_state_lock taken, otherwise,
	* return (NULL) without the taking locks. The zv_suspend_lock is always taken
	* before zv_state_lock. The mode argument indicates the mode (including none)
	* for zv_suspend_lock to be taken.
	*/
	static zvol_state_t *
	zvol_find_by_name(const char *name, int mode)
	{
	return (zvol_find_by_name_hash(name, zvol_name_hash(name), mode));
	}

	/*
	* ZFS_IOC_CREATE callback handles dmu zvol and zap object creation.
	*/
	void
	zvol_create_cb(objset_t os, void arg, cred_t cr, dmu_tx_t tx)
	{
	zfs_creat_t *zct = arg;
	nvlist_t *nvprops = zct->zct_props;
	int error;
	uint64_t volblocksize, volsize;

	VERIFY(nvlist_lookup_uint64(nvprops,
	zfs_prop_to_name(ZFS_PROP_VOLSIZE), &volsize) == 0);
	if (nvlist_lookup_uint64(nvprops,
	zfs_prop_to_name(ZFS_PROP_VOLBLOCKSIZE), &volblocksize) != 0)
	volblocksize = zfs_prop_default_numeric(ZFS_PROP_VOLBLOCKSIZE);

	/*
	* These properties must be removed from the list so the generic
	* property setting step won't apply to them.
	*/
	VERIFY(nvlist_remove_all(nvprops,
	zfs_prop_to_name(ZFS_PROP_VOLSIZE)) == 0);
	(void) nvlist_remove_all(nvprops,
	zfs_prop_to_name(ZFS_PROP_VOLBLOCKSIZE));

	error = dmu_object_claim(os, ZVOL_OBJ, DMU_OT_ZVOL, volblocksize,
	DMU_OT_NONE, 0, tx);
	ASSERT(error == 0);

	error = zap_create_claim(os, ZVOL_ZAP_OBJ, DMU_OT_ZVOL_PROP,
	DMU_OT_NONE, 0, tx);
	ASSERT(error == 0);

	error = zap_update(os, ZVOL_ZAP_OBJ, "size", 8, 1, &volsize, tx);
	ASSERT(error == 0);
	}

	/*
	* ZFS_IOC_OBJSET_STATS entry point.
	*/
	int
	zvol_get_stats(objset_t os, nvlist_t nv)
	{
	int error;
	dmu_object_info_t *doi;
	uint64_t val;

	error = zap_lookup(os, ZVOL_ZAP_OBJ, "size", 8, 1, &val);
	if (error)
	return (SET_ERROR(error));

	dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_VOLSIZE, val);
	doi = kmem_alloc(sizeof (dmu_object_info_t), KM_SLEEP);
	error = dmu_object_info(os, ZVOL_OBJ, doi);

	if (error == 0) {
	dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_VOLBLOCKSIZE,
	doi->doi_data_block_size);
	}

	kmem_free(doi, sizeof (dmu_object_info_t));

	return (SET_ERROR(error));
	}

	/*
	* Sanity check volume size.
	*/
	int
	zvol_check_volsize(uint64_t volsize, uint64_t blocksize)
	{
	if (volsize == 0)
	return (SET_ERROR(EINVAL));

	if (volsize % blocksize != 0)
	return (SET_ERROR(EINVAL));

	#ifdef _ILP32
	if (volsize - 1 > SPEC_MAXOFFSET_T)
	return (SET_ERROR(EOVERFLOW));
	#endif
	return (0);
	}

	/*
	* Ensure the zap is flushed then inform the VFS of the capacity change.
	*/
	static int
	zvol_update_volsize(uint64_t volsize, objset_t *os)
	{
	dmu_tx_t *tx;
	int error;
	uint64_t txg;

	tx = dmu_tx_create(os);
	dmu_tx_hold_zap(tx, ZVOL_ZAP_OBJ, TRUE, NULL);
	dmu_tx_mark_netfree(tx);
	error = dmu_tx_assign(tx, TXG_WAIT);
	if (error) {
	dmu_tx_abort(tx);
	return (SET_ERROR(error));
	}
	txg = dmu_tx_get_txg(tx);

	error = zap_update(os, ZVOL_ZAP_OBJ, "size", 8, 1,
	&volsize, tx);
	dmu_tx_commit(tx);

	txg_wait_synced(dmu_objset_pool(os), txg);

	if (error == 0)
	error = dmu_free_long_range(os,
	ZVOL_OBJ, volsize, DMU_OBJECT_END);

	return (error);
	}

	/*
	* Set ZFS_PROP_VOLSIZE set entry point. Note that modifying the volume
	* size will result in a udev "change" event being generated.
	*/
	int
	zvol_set_volsize(const char *name, uint64_t volsize)
	{
	objset_t *os = NULL;
	uint64_t readonly;
	int error;
	boolean_t owned = B_FALSE;

	error = dsl_prop_get_integer(name,
	zfs_prop_to_name(ZFS_PROP_READONLY), &readonly, NULL);
	if (error != 0)
	return (SET_ERROR(error));
	if (readonly)
	return (SET_ERROR(EROFS));

	zvol_state_t *zv = zvol_find_by_name(name, RW_READER);

	ASSERT(zv == NULL \|\| (MUTEX_HELD(&zv->zv_state_lock) &&
	RW_READ_HELD(&zv->zv_suspend_lock)));

	if (zv == NULL \|\| zv->zv_objset == NULL) {
	if (zv != NULL)
	rw_exit(&zv->zv_suspend_lock);
	if ((error = dmu_objset_own(name, DMU_OST_ZVOL, B_FALSE, B_TRUE,
	FTAG, &os)) != 0) {
	if (zv != NULL)
	mutex_exit(&zv->zv_state_lock);
	return (SET_ERROR(error));
	}
	owned = B_TRUE;
	if (zv != NULL)
	zv->zv_objset = os;
	} else {
	os = zv->zv_objset;
	}

	dmu_object_info_t doi = kmem_alloc(sizeof (doi), KM_SLEEP);

	if ((error = dmu_object_info(os, ZVOL_OBJ, doi)) \|\|
	(error = zvol_check_volsize(volsize, doi->doi_data_block_size)))
	goto out;

	error = zvol_update_volsize(volsize, os);
	if (error == 0 && zv != NULL) {
	zv->zv_volsize = volsize;
	zv->zv_changed = 1;
	}
	out:
	kmem_free(doi, sizeof (dmu_object_info_t));

	if (owned) {
	dmu_objset_disown(os, B_TRUE, FTAG);
	if (zv != NULL)
	zv->zv_objset = NULL;
	} else {
	rw_exit(&zv->zv_suspend_lock);
	}

	if (zv != NULL)
	mutex_exit(&zv->zv_state_lock);

	if (error == 0 && zv != NULL)
	ops->zv_update_volsize(zv, volsize);

	return (SET_ERROR(error));
	}

	/*
	* Sanity check volume block size.
	*/
	int
	zvol_check_volblocksize(const char *name, uint64_t volblocksize)
	{
	/* Record sizes above 128k need the feature to be enabled */
	if (volblocksize > SPA_OLD_MAXBLOCKSIZE) {
	spa_t *spa;
	int error;

	if ((error = spa_open(name, &spa, FTAG)) != 0)
	return (error);

	if (!spa_feature_is_enabled(spa, SPA_FEATURE_LARGE_BLOCKS)) {
	spa_close(spa, FTAG);
	return (SET_ERROR(ENOTSUP));
	}

	/*
	* We don't allow setting the property above 1MB,
	* unless the tunable has been changed.
	*/
	if (volblocksize > zfs_max_recordsize)
	return (SET_ERROR(EDOM));

	spa_close(spa, FTAG);
	}

	if (volblocksize < SPA_MINBLOCKSIZE \|\|
	volblocksize > SPA_MAXBLOCKSIZE \|\|
	!ISP2(volblocksize))
	return (SET_ERROR(EDOM));

	return (0);
	}

	/*
	* Set ZFS_PROP_VOLBLOCKSIZE set entry point.
	*/
	int
	zvol_set_volblocksize(const char *name, uint64_t volblocksize)
	{
	zvol_state_t *zv;
	dmu_tx_t *tx;
	int error;

	zv = zvol_find_by_name(name, RW_READER);

	if (zv == NULL)
	return (SET_ERROR(ENXIO));

	ASSERT(MUTEX_HELD(&zv->zv_state_lock));
	ASSERT(RW_READ_HELD(&zv->zv_suspend_lock));

	if (zv->zv_flags & ZVOL_RDONLY) {
	mutex_exit(&zv->zv_state_lock);
	rw_exit(&zv->zv_suspend_lock);
	return (SET_ERROR(EROFS));
	}

	tx = dmu_tx_create(zv->zv_objset);
	dmu_tx_hold_bonus(tx, ZVOL_OBJ);
	error = dmu_tx_assign(tx, TXG_WAIT);
	if (error) {
	dmu_tx_abort(tx);
	} else {
	error = dmu_object_set_blocksize(zv->zv_objset, ZVOL_OBJ,
	volblocksize, 0, tx);
	if (error == ENOTSUP)
	error = SET_ERROR(EBUSY);
	dmu_tx_commit(tx);
	if (error == 0)
	zv->zv_volblocksize = volblocksize;
	}

	mutex_exit(&zv->zv_state_lock);
	rw_exit(&zv->zv_suspend_lock);

	return (SET_ERROR(error));
	}

	/*
	* Replay a TX_TRUNCATE ZIL transaction if asked. TX_TRUNCATE is how we
	* implement DKIOCFREE/free-long-range.
	*/
	static int
	zvol_replay_truncate(void arg1, void arg2, boolean_t byteswap)
	{
	zvol_state_t *zv = arg1;
	lr_truncate_t *lr = arg2;
	uint64_t offset, length;

	if (byteswap)
	byteswap_uint64_array(lr, sizeof (*lr));

	offset = lr->lr_offset;
	length = lr->lr_length;

	dmu_tx_t *tx = dmu_tx_create(zv->zv_objset);
	dmu_tx_mark_netfree(tx);
	int error = dmu_tx_assign(tx, TXG_WAIT);
	if (error != 0) {
	dmu_tx_abort(tx);
	} else {
	zil_replaying(zv->zv_zilog, tx);
	dmu_tx_commit(tx);
	error = dmu_free_long_range(zv->zv_objset, ZVOL_OBJ, offset,
	length);
	}

	return (error);
	}

	/*
	* Replay a TX_WRITE ZIL transaction that didn't get committed
	* after a system failure
	*/
	static int
	zvol_replay_write(void arg1, void arg2, boolean_t byteswap)
	{
	zvol_state_t *zv = arg1;
	lr_write_t *lr = arg2;
	objset_t *os = zv->zv_objset;
	char data = (char )(lr + 1); /* data follows lr_write_t */
	uint64_t offset, length;
	dmu_tx_t *tx;
	int error;

	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;
	}
	}

	tx = dmu_tx_create(os);
	dmu_tx_hold_write(tx, ZVOL_OBJ, offset, length);
	error = dmu_tx_assign(tx, TXG_WAIT);
	if (error) {
	dmu_tx_abort(tx);
	} else {
	dmu_write(os, ZVOL_OBJ, offset, length, data, tx);
	zil_replaying(zv->zv_zilog, tx);
	dmu_tx_commit(tx);
	}

	return (error);
	}

	static int
	zvol_replay_err(void arg1, void arg2, boolean_t byteswap)
	{
	return (SET_ERROR(ENOTSUP));
	}

	/*
	* Callback vectors for replaying records.
	* Only TX_WRITE and TX_TRUNCATE are needed for zvol.
	*/
	zil_replay_func_t *zvol_replay_vector[TX_MAX_TYPE] = {
	zvol_replay_err, /* no such transaction type */
	zvol_replay_err, /* TX_CREATE */
	zvol_replay_err, /* TX_MKDIR */
	zvol_replay_err, /* TX_MKXATTR */
	zvol_replay_err, /* TX_SYMLINK */
	zvol_replay_err, /* TX_REMOVE */
	zvol_replay_err, /* TX_RMDIR */
	zvol_replay_err, /* TX_LINK */
	zvol_replay_err, /* TX_RENAME */
	zvol_replay_write, /* TX_WRITE */
	zvol_replay_truncate, /* TX_TRUNCATE */
	zvol_replay_err, /* TX_SETATTR */
	zvol_replay_err, /* TX_ACL */
	zvol_replay_err, /* TX_CREATE_ATTR */
	zvol_replay_err, /* TX_CREATE_ACL_ATTR */
	zvol_replay_err, /* TX_MKDIR_ACL */
	zvol_replay_err, /* TX_MKDIR_ATTR */
	zvol_replay_err, /* TX_MKDIR_ACL_ATTR */
	zvol_replay_err, /* TX_WRITE2 */
	};

	/*
	* zvol_log_write() handles synchronous writes using TX_WRITE ZIL transactions.
	*
	* We store data in the log buffers if it's small enough.
	* Otherwise we will later flush the data out via dmu_sync().
	*/
	ssize_t zvol_immediate_write_sz = 32768;

	void
	zvol_log_write(zvol_state_t zv, dmu_tx_t tx, uint64_t offset,
	uint64_t size, int sync)
	{
	uint32_t blocksize = zv->zv_volblocksize;
	zilog_t *zilog = zv->zv_zilog;
	itx_wr_state_t write_state;

	if (zil_replaying(zilog, tx))
	return;

	if (zilog->zl_logbias == ZFS_LOGBIAS_THROUGHPUT)
	write_state = WR_INDIRECT;
	else if (!spa_has_slogs(zilog->zl_spa) &&
	size >= blocksize && blocksize > zvol_immediate_write_sz)
	write_state = WR_INDIRECT;
	else if (sync)
	write_state = WR_COPIED;
	else
	write_state = WR_NEED_COPY;

	while (size) {
	itx_t *itx;
	lr_write_t *lr;
	itx_wr_state_t wr_state = write_state;
	ssize_t len = size;

	if (wr_state == WR_COPIED && size > zil_max_copied_data(zilog))
	wr_state = WR_NEED_COPY;
	else if (wr_state == WR_INDIRECT)
	len = MIN(blocksize - P2PHASE(offset, blocksize), size);

	itx = zil_itx_create(TX_WRITE, sizeof (*lr) +
	(wr_state == WR_COPIED ? len : 0));
	lr = (lr_write_t *)&itx->itx_lr;
	if (wr_state == WR_COPIED && dmu_read_by_dnode(zv->zv_dn,
	offset, len, lr+1, DMU_READ_NO_PREFETCH) != 0) {
	zil_itx_destroy(itx);
	itx = zil_itx_create(TX_WRITE, sizeof (*lr));
	lr = (lr_write_t *)&itx->itx_lr;
	wr_state = WR_NEED_COPY;
	}

	itx->itx_wr_state = wr_state;
	lr->lr_foid = ZVOL_OBJ;
	lr->lr_offset = offset;
	lr->lr_length = len;
	lr->lr_blkoff = 0;
	BP_ZERO(&lr->lr_blkptr);

	itx->itx_private = zv;
	itx->itx_sync = sync;

	(void) zil_itx_assign(zilog, itx, tx);

	offset += len;
	size -= len;
	}
	}

	/*
	* Log a DKIOCFREE/free-long-range to the ZIL with TX_TRUNCATE.
	*/
	void
	zvol_log_truncate(zvol_state_t zv, dmu_tx_t tx, uint64_t off, uint64_t len,
	boolean_t sync)
	{
	itx_t *itx;
	lr_truncate_t *lr;
	zilog_t *zilog = zv->zv_zilog;

	if (zil_replaying(zilog, tx))
	return;

	itx = zil_itx_create(TX_TRUNCATE, sizeof (*lr));
	lr = (lr_truncate_t *)&itx->itx_lr;
	lr->lr_foid = ZVOL_OBJ;
	lr->lr_offset = off;
	lr->lr_length = len;

	itx->itx_sync = sync;
	zil_itx_assign(zilog, itx, tx);
	}


	/* ARGSUSED */
	static void
	zvol_get_done(zgd_t *zgd, int error)
	{
	if (zgd->zgd_db)
	dmu_buf_rele(zgd->zgd_db, zgd);

	zfs_rangelock_exit(zgd->zgd_lr);

	kmem_free(zgd, sizeof (zgd_t));
	}

	/*
	* Get data to generate a TX_WRITE intent log record.
	*/
	int
	zvol_get_data(void arg, uint64_t arg2, lr_write_t lr, char *buf,
	struct lwb lwb, zio_t zio)
	{
	zvol_state_t *zv = arg;
	uint64_t offset = lr->lr_offset;
	uint64_t size = lr->lr_length;
	dmu_buf_t *db;
	zgd_t *zgd;
	int error;

	ASSERT3P(lwb, !=, NULL);
	ASSERT3P(zio, !=, NULL);
	ASSERT3U(size, !=, 0);

	zgd = (zgd_t *)kmem_zalloc(sizeof (zgd_t), KM_SLEEP);
	zgd->zgd_lwb = lwb;

	/*
	* Write records come in two flavors: immediate and indirect.
	* For small writes it's cheaper to store the data with the
	* log record (immediate); for large writes it's cheaper to
	* sync the data and get a pointer to it (indirect) so that
	* we don't have to write the data twice.
	*/
	if (buf != NULL) { /* immediate write */
	zgd->zgd_lr = zfs_rangelock_enter(&zv->zv_rangelock, offset,
	size, RL_READER);
	error = dmu_read_by_dnode(zv->zv_dn, offset, size, buf,
	DMU_READ_NO_PREFETCH);
	} else { /* indirect write */
	/*
	* Have to lock the whole block to ensure when it's written out
	* and its checksum is being calculated that no one can change
	* the data. Contrarily to zfs_get_data we need not re-check
	* blocksize after we get the lock because it cannot be changed.
	*/
	size = zv->zv_volblocksize;
	offset = P2ALIGN_TYPED(offset, size, uint64_t);
	zgd->zgd_lr = zfs_rangelock_enter(&zv->zv_rangelock, offset,
	size, RL_READER);
	error = dmu_buf_hold_by_dnode(zv->zv_dn, offset, zgd, &db,
	DMU_READ_NO_PREFETCH);
	if (error == 0) {
	blkptr_t *bp = &lr->lr_blkptr;

	zgd->zgd_db = db;
	zgd->zgd_bp = bp;

	ASSERT(db != NULL);
	ASSERT(db->db_offset == offset);
	ASSERT(db->db_size == size);

	error = dmu_sync(zio, lr->lr_common.lrc_txg,
	zvol_get_done, zgd);

	if (error == 0)
	return (0);
	}
	}

	zvol_get_done(zgd, error);

	return (SET_ERROR(error));
	}

	/*
	* The zvol_state_t's are inserted into zvol_state_list and zvol_htable.
	*/

	void
	zvol_insert(zvol_state_t *zv)
	{
	ASSERT(RW_WRITE_HELD(&zvol_state_lock));
	list_insert_head(&zvol_state_list, zv);
	hlist_add_head(&zv->zv_hlink, ZVOL_HT_HEAD(zv->zv_hash));
	}

	/*
	* Simply remove the zvol from to list of zvols.
	*/
	static void
	zvol_remove(zvol_state_t *zv)
	{
	ASSERT(RW_WRITE_HELD(&zvol_state_lock));
	list_remove(&zvol_state_list, zv);
	hlist_del(&zv->zv_hlink);
	}

	/*
	* Setup zv after we just own the zv->objset
	*/
	static int
	zvol_setup_zv(zvol_state_t *zv)
	{
	uint64_t volsize;
	int error;
	uint64_t ro;
	objset_t *os = zv->zv_objset;

	ASSERT(MUTEX_HELD(&zv->zv_state_lock));
	ASSERT(RW_LOCK_HELD(&zv->zv_suspend_lock));

	zv->zv_zilog = NULL;
	zv->zv_flags &= ~ZVOL_WRITTEN_TO;

	error = dsl_prop_get_integer(zv->zv_name, "readonly", &ro, NULL);
	if (error)
	return (SET_ERROR(error));

	error = zap_lookup(os, ZVOL_ZAP_OBJ, "size", 8, 1, &volsize);
	if (error)
	return (SET_ERROR(error));

	error = dnode_hold(os, ZVOL_OBJ, zv, &zv->zv_dn);
	if (error)
	return (SET_ERROR(error));

	ops->zv_set_capacity(zv, volsize >> 9);
	zv->zv_volsize = volsize;

	if (ro \|\| dmu_objset_is_snapshot(os) \|\|
	!spa_writeable(dmu_objset_spa(os))) {
	ops->zv_set_disk_ro(zv, 1);
	zv->zv_flags \|= ZVOL_RDONLY;
	} else {
	ops->zv_set_disk_ro(zv, 0);
	zv->zv_flags &= ~ZVOL_RDONLY;
	}
	return (0);
	}

	/*
	* Shutdown every zv_objset related stuff except zv_objset itself.
	* The is the reverse of zvol_setup_zv.
	*/
	static void
	zvol_shutdown_zv(zvol_state_t *zv)
	{
	ASSERT(MUTEX_HELD(&zv->zv_state_lock) &&
	RW_LOCK_HELD(&zv->zv_suspend_lock));

	if (zv->zv_flags & ZVOL_WRITTEN_TO) {
	ASSERT(zv->zv_zilog != NULL);
	zil_close(zv->zv_zilog);
	}

	zv->zv_zilog = NULL;

	dnode_rele(zv->zv_dn, zv);
	zv->zv_dn = NULL;

	/*
	* Evict cached data. We must write out any dirty data before
	* disowning the dataset.
	*/
	if (zv->zv_flags & ZVOL_WRITTEN_TO)
	txg_wait_synced(dmu_objset_pool(zv->zv_objset), 0);
	(void) dmu_objset_evict_dbufs(zv->zv_objset);
	}

	/*
	* return the proper tag for rollback and recv
	*/
	void *
	zvol_tag(zvol_state_t *zv)
	{
	ASSERT(RW_WRITE_HELD(&zv->zv_suspend_lock));
	return (zv->zv_open_count > 0 ? zv : NULL);
	}

	/*
	* Suspend the zvol for recv and rollback.
	*/
	zvol_state_t *
	zvol_suspend(const char *name)
	{
	zvol_state_t *zv;

	zv = zvol_find_by_name(name, RW_WRITER);

	if (zv == NULL)
	return (NULL);

	/* block all I/O, release in zvol_resume. */
	ASSERT(MUTEX_HELD(&zv->zv_state_lock));
	ASSERT(RW_WRITE_HELD(&zv->zv_suspend_lock));

	atomic_inc(&zv->zv_suspend_ref);

	if (zv->zv_open_count > 0)
	zvol_shutdown_zv(zv);

	/*
	* do not hold zv_state_lock across suspend/resume to
	* avoid locking up zvol lookups
	*/
	mutex_exit(&zv->zv_state_lock);

	/* zv_suspend_lock is released in zvol_resume() */
	return (zv);
	}

	int
	zvol_resume(zvol_state_t *zv)
	{
	int error = 0;

	ASSERT(RW_WRITE_HELD(&zv->zv_suspend_lock));

	mutex_enter(&zv->zv_state_lock);

	if (zv->zv_open_count > 0) {
	VERIFY0(dmu_objset_hold(zv->zv_name, zv, &zv->zv_objset));
	VERIFY3P(zv->zv_objset->os_dsl_dataset->ds_owner, ==, zv);
	VERIFY(dsl_dataset_long_held(zv->zv_objset->os_dsl_dataset));
	dmu_objset_rele(zv->zv_objset, zv);

	error = zvol_setup_zv(zv);
	}

	mutex_exit(&zv->zv_state_lock);

	rw_exit(&zv->zv_suspend_lock);
	/*
	* We need this because we don't hold zvol_state_lock while releasing
	* zv_suspend_lock. zvol_remove_minors_impl thus cannot check
	* zv_suspend_lock to determine it is safe to free because rwlock is
	* not inherent atomic.
	*/
	atomic_dec(&zv->zv_suspend_ref);

	return (SET_ERROR(error));
	}

	int
	zvol_first_open(zvol_state_t *zv, boolean_t readonly)
	{
	objset_t *os;
	- int error, locked = 0;
	- boolean_t ro;
	+ int error;

	ASSERT(RW_READ_HELD(&zv->zv_suspend_lock));
	ASSERT(MUTEX_HELD(&zv->zv_state_lock));
	+ ASSERT(mutex_owned(&spa_namespace_lock));

	- /*
	- * In all other cases the spa_namespace_lock is taken before the
	- * bdev->bd_mutex lock. But in this case the Linux __blkdev_get()
	- * function calls fops->open() with the bdev->bd_mutex lock held.
	- * This deadlock can be easily observed with zvols used as vdevs.
	- *
	- * To avoid a potential lock inversion deadlock we preemptively
	- * try to take the spa_namespace_lock(). Normally it will not
	- * be contended and this is safe because spa_open_common() handles
	- * the case where the caller already holds the spa_namespace_lock.
	- *
	- * When it is contended we risk a lock inversion if we were to
	- * block waiting for the lock. Luckily, the __blkdev_get()
	- * function allows us to return -ERESTARTSYS which will result in
	- * bdev->bd_mutex being dropped, reacquired, and fops->open() being
	- * called again. This process can be repeated safely until both
	- * locks are acquired.
	- */
	- if (!mutex_owned(&spa_namespace_lock)) {
	- locked = mutex_tryenter(&spa_namespace_lock);
	- if (!locked)
	- return (SET_ERROR(EINTR));
	- }
	-
	- ro = (readonly \|\| (strchr(zv->zv_name, '@') != NULL));
	+ boolean_t ro = (readonly \|\| (strchr(zv->zv_name, '@') != NULL));
	error = dmu_objset_own(zv->zv_name, DMU_OST_ZVOL, ro, B_TRUE, zv, &os);
	if (error)
	- goto out_mutex;
	+ return (SET_ERROR(error));

	zv->zv_objset = os;

	error = zvol_setup_zv(zv);
	-
	if (error) {
	dmu_objset_disown(os, 1, zv);
	zv->zv_objset = NULL;
	}

	-out_mutex:
	- if (locked)
	- mutex_exit(&spa_namespace_lock);
	- return (SET_ERROR(error));
	+ return (error);
	}

	void
	zvol_last_close(zvol_state_t *zv)
	{
	ASSERT(RW_READ_HELD(&zv->zv_suspend_lock));
	ASSERT(MUTEX_HELD(&zv->zv_state_lock));

	zvol_shutdown_zv(zv);

	dmu_objset_disown(zv->zv_objset, 1, zv);
	zv->zv_objset = NULL;
	}

	typedef struct minors_job {
	list_t *list;
	list_node_t link;
	/* input */
	char *name;
	/* output */
	int error;
	} minors_job_t;

	/*
	* Prefetch zvol dnodes for the minors_job
	*/
	static void
	zvol_prefetch_minors_impl(void *arg)
	{
	minors_job_t *job = arg;
	char *dsname = job->name;
	objset_t *os = NULL;

	job->error = dmu_objset_own(dsname, DMU_OST_ZVOL, B_TRUE, B_TRUE,
	FTAG, &os);
	if (job->error == 0) {
	dmu_prefetch(os, ZVOL_OBJ, 0, 0, 0, ZIO_PRIORITY_SYNC_READ);
	dmu_objset_disown(os, B_TRUE, FTAG);
	}
	}

	/*
	* Mask errors to continue dmu_objset_find() traversal
	*/
	static int
	zvol_create_snap_minor_cb(const char dsname, void arg)
	{
	minors_job_t *j = arg;
	list_t *minors_list = j->list;
	const char *name = j->name;

	ASSERT0(MUTEX_HELD(&spa_namespace_lock));

	/* skip the designated dataset */
	if (name && strcmp(dsname, name) == 0)
	return (0);

	/* at this point, the dsname should name a snapshot */
	if (strchr(dsname, '@') == 0) {
	dprintf("zvol_create_snap_minor_cb(): "
	"%s is not a snapshot name\n", dsname);
	} else {
	minors_job_t *job;
	char *n = kmem_strdup(dsname);
	if (n == NULL)
	return (0);

	job = kmem_alloc(sizeof (minors_job_t), KM_SLEEP);
	job->name = n;
	job->list = minors_list;
	job->error = 0;
	list_insert_tail(minors_list, job);
	/* don't care if dispatch fails, because job->error is 0 */
	taskq_dispatch(system_taskq, zvol_prefetch_minors_impl, job,
	TQ_SLEEP);
	}

	return (0);
	}

	+/*
	+ * If spa_keystore_load_wkey() is called for an encrypted zvol,
	+ * we need to look for any clones also using the key. This function
	+ * is "best effort" - so we just skip over it if there are failures.
	+ */
	+static void
	+zvol_add_clones(const char dsname, list_t minors_list)
	+{
	+ /* Also check if it has clones */
	+ dsl_dir_t *dd = NULL;
	+ dsl_pool_t *dp = NULL;
	+
	+ if (dsl_pool_hold(dsname, FTAG, &dp) != 0)
	+ return;
	+
	+ if (!spa_feature_is_enabled(dp->dp_spa,
	+ SPA_FEATURE_ENCRYPTION))
	+ goto out;
	+
	+ if (dsl_dir_hold(dp, dsname, FTAG, &dd, NULL) != 0)
	+ goto out;
	+
	+ if (dsl_dir_phys(dd)->dd_clones == 0)
	+ goto out;
	+
	+ zap_cursor_t *zc = kmem_alloc(sizeof (zap_cursor_t), KM_SLEEP);
	+ zap_attribute_t *za = kmem_alloc(sizeof (zap_attribute_t), KM_SLEEP);
	+ objset_t *mos = dd->dd_pool->dp_meta_objset;
	+
	+ for (zap_cursor_init(zc, mos, dsl_dir_phys(dd)->dd_clones);
	+ zap_cursor_retrieve(zc, za) == 0;
	+ zap_cursor_advance(zc)) {
	+ dsl_dataset_t *clone;
	+ minors_job_t *job;
	+
	+ if (dsl_dataset_hold_obj(dd->dd_pool,
	+ za->za_first_integer, FTAG, &clone) == 0) {
	+
	+ char name[ZFS_MAX_DATASET_NAME_LEN];
	+ dsl_dataset_name(clone, name);
	+
	+ char *n = kmem_strdup(name);
	+ job = kmem_alloc(sizeof (minors_job_t), KM_SLEEP);
	+ job->name = n;
	+ job->list = minors_list;
	+ job->error = 0;
	+ list_insert_tail(minors_list, job);
	+
	+ dsl_dataset_rele(clone, FTAG);
	+ }
	+ }
	+ zap_cursor_fini(zc);
	+ kmem_free(za, sizeof (zap_attribute_t));
	+ kmem_free(zc, sizeof (zap_cursor_t));
	+
	+out:
	+ if (dd != NULL)
	+ dsl_dir_rele(dd, FTAG);
	+ if (dp != NULL)
	+ dsl_pool_rele(dp, FTAG);
	+}
	+
	/*
	* Mask errors to continue dmu_objset_find() traversal
	*/
	static int
	zvol_create_minors_cb(const char dsname, void arg)
	{
	uint64_t snapdev;
	int error;
	list_t *minors_list = arg;

	ASSERT0(MUTEX_HELD(&spa_namespace_lock));

	error = dsl_prop_get_integer(dsname, "snapdev", &snapdev, NULL);
	if (error)
	return (0);

	/*
	* Given the name and the 'snapdev' property, create device minor nodes
	* with the linkages to zvols/snapshots as needed.
	* If the name represents a zvol, create a minor node for the zvol, then
	* check if its snapshots are 'visible', and if so, iterate over the
	* snapshots and create device minor nodes for those.
	*/
	if (strchr(dsname, '@') == 0) {
	minors_job_t *job;
	char *n = kmem_strdup(dsname);
	if (n == NULL)
	return (0);

	job = kmem_alloc(sizeof (minors_job_t), KM_SLEEP);
	job->name = n;
	job->list = minors_list;
	job->error = 0;
	list_insert_tail(minors_list, job);
	/* don't care if dispatch fails, because job->error is 0 */
	taskq_dispatch(system_taskq, zvol_prefetch_minors_impl, job,
	TQ_SLEEP);

	+ zvol_add_clones(dsname, minors_list);
	+
	if (snapdev == ZFS_SNAPDEV_VISIBLE) {
	/*
	* traverse snapshots only, do not traverse children,
	* and skip the 'dsname'
	*/
	error = dmu_objset_find(dsname,
	zvol_create_snap_minor_cb, (void *)job,
	DS_FIND_SNAPSHOTS);
	}
	} else {
	dprintf("zvol_create_minors_cb(): %s is not a zvol name\n",
	dsname);
	}

	return (0);
	}

	/*
	* Create minors for the specified dataset, including children and snapshots.
	* Pay attention to the 'snapdev' property and iterate over the snapshots
	* only if they are 'visible'. This approach allows one to assure that the
	* snapshot metadata is read from disk only if it is needed.
	*
	* The name can represent a dataset to be recursively scanned for zvols and
	* their snapshots, or a single zvol snapshot. If the name represents a
	* dataset, the scan is performed in two nested stages:
	* - scan the dataset for zvols, and
	* - for each zvol, create a minor node, then check if the zvol's snapshots
	* are 'visible', and only then iterate over the snapshots if needed
	*
	* If the name represents a snapshot, a check is performed if the snapshot is
	* 'visible' (which also verifies that the parent is a zvol), and if so,
	* a minor node for that snapshot is created.
	*/
	void
	zvol_create_minors_recursive(const char *name)
	{
	list_t minors_list;
	minors_job_t *job;

	if (zvol_inhibit_dev)
	return;

	/*
	* This is the list for prefetch jobs. Whenever we found a match
	* during dmu_objset_find, we insert a minors_job to the list and do
	* taskq_dispatch to parallel prefetch zvol dnodes. Note we don't need
	* any lock because all list operation is done on the current thread.
	*
	* We will use this list to do zvol_create_minor_impl after prefetch
	* so we don't have to traverse using dmu_objset_find again.
	*/
	list_create(&minors_list, sizeof (minors_job_t),
	offsetof(minors_job_t, link));


	if (strchr(name, '@') != NULL) {
	uint64_t snapdev;

	int error = dsl_prop_get_integer(name, "snapdev",
	&snapdev, NULL);

	if (error == 0 && snapdev == ZFS_SNAPDEV_VISIBLE)
	(void) ops->zv_create_minor(name);
	} else {
	fstrans_cookie_t cookie = spl_fstrans_mark();
	(void) dmu_objset_find(name, zvol_create_minors_cb,
	&minors_list, DS_FIND_CHILDREN);
	spl_fstrans_unmark(cookie);
	}

	taskq_wait_outstanding(system_taskq, 0);

	/*
	* Prefetch is completed, we can do zvol_create_minor_impl
	* sequentially.
	*/
	while ((job = list_head(&minors_list)) != NULL) {
	list_remove(&minors_list, job);
	if (!job->error)
	(void) ops->zv_create_minor(job->name);
	kmem_strfree(job->name);
	kmem_free(job, sizeof (minors_job_t));
	}

	list_destroy(&minors_list);
	}

	void
	zvol_create_minor(const char *name)
	{
	/*
	* Note: the dsl_pool_config_lock must not be held.
	* Minor node creation needs to obtain the zvol_state_lock.
	* zvol_open() obtains the zvol_state_lock and then the dsl pool
	* config lock. Therefore, we can't have the config lock now if
	* we are going to wait for the zvol_state_lock, because it
	* would be a lock order inversion which could lead to deadlock.
	*/

	if (zvol_inhibit_dev)
	return;

	if (strchr(name, '@') != NULL) {
	uint64_t snapdev;

	int error = dsl_prop_get_integer(name,
	"snapdev", &snapdev, NULL);

	if (error == 0 && snapdev == ZFS_SNAPDEV_VISIBLE)
	(void) ops->zv_create_minor(name);
	} else {
	(void) ops->zv_create_minor(name);
	}
	}

	/*
	* Remove minors for specified dataset including children and snapshots.
	*/

	static void
	zvol_free_task(void *arg)
	{
	ops->zv_free(arg);
	}

	void
	zvol_remove_minors_impl(const char *name)
	{
	zvol_state_t zv, zv_next;
	int namelen = ((name) ? strlen(name) : 0);
	taskqid_t t;
	list_t free_list;

	if (zvol_inhibit_dev)
	return;

	list_create(&free_list, sizeof (zvol_state_t),
	offsetof(zvol_state_t, zv_next));

	rw_enter(&zvol_state_lock, RW_WRITER);

	for (zv = list_head(&zvol_state_list); zv != NULL; zv = zv_next) {
	zv_next = list_next(&zvol_state_list, zv);

	mutex_enter(&zv->zv_state_lock);
	if (name == NULL \|\| strcmp(zv->zv_name, name) == 0 \|\|
	(strncmp(zv->zv_name, name, namelen) == 0 &&
	(zv->zv_name[namelen] == '/' \|\|
	zv->zv_name[namelen] == '@'))) {
	/*
	* By holding zv_state_lock here, we guarantee that no
	* one is currently using this zv
	*/

	/* If in use, leave alone */
	if (zv->zv_open_count > 0 \|\|
	atomic_read(&zv->zv_suspend_ref)) {
	mutex_exit(&zv->zv_state_lock);
	continue;
	}

	zvol_remove(zv);

	/*
	* Cleared while holding zvol_state_lock as a writer
	* which will prevent zvol_open() from opening it.
	*/
	ops->zv_clear_private(zv);

	/* Drop zv_state_lock before zvol_free() */
	mutex_exit(&zv->zv_state_lock);

	/* Try parallel zv_free, if failed do it in place */
	t = taskq_dispatch(system_taskq, zvol_free_task, zv,
	TQ_SLEEP);
	if (t == TASKQID_INVALID)
	list_insert_head(&free_list, zv);
	} else {
	mutex_exit(&zv->zv_state_lock);
	}
	}
	rw_exit(&zvol_state_lock);

	/* Drop zvol_state_lock before calling zvol_free() */
	while ((zv = list_head(&free_list)) != NULL) {
	list_remove(&free_list, zv);
	ops->zv_free(zv);
	}
	}

	/* Remove minor for this specific volume only */
	static void
	zvol_remove_minor_impl(const char *name)
	{
	zvol_state_t zv = NULL, zv_next;

	if (zvol_inhibit_dev)
	return;

	rw_enter(&zvol_state_lock, RW_WRITER);

	for (zv = list_head(&zvol_state_list); zv != NULL; zv = zv_next) {
	zv_next = list_next(&zvol_state_list, zv);

	mutex_enter(&zv->zv_state_lock);
	if (strcmp(zv->zv_name, name) == 0) {
	/*
	* By holding zv_state_lock here, we guarantee that no
	* one is currently using this zv
	*/

	/* If in use, leave alone */
	if (zv->zv_open_count > 0 \|\|
	atomic_read(&zv->zv_suspend_ref)) {
	mutex_exit(&zv->zv_state_lock);
	continue;
	}
	zvol_remove(zv);

	ops->zv_clear_private(zv);
	mutex_exit(&zv->zv_state_lock);
	break;
	} else {
	mutex_exit(&zv->zv_state_lock);
	}
	}

	/* Drop zvol_state_lock before calling zvol_free() */
	rw_exit(&zvol_state_lock);

	if (zv != NULL)
	ops->zv_free(zv);
	}

	/*
	* Rename minors for specified dataset including children and snapshots.
	*/
	static void
	zvol_rename_minors_impl(const char oldname, const char newname)
	{
	zvol_state_t zv, zv_next;
	int oldnamelen, newnamelen;

	if (zvol_inhibit_dev)
	return;

	oldnamelen = strlen(oldname);
	newnamelen = strlen(newname);

	rw_enter(&zvol_state_lock, RW_READER);

	for (zv = list_head(&zvol_state_list); zv != NULL; zv = zv_next) {
	zv_next = list_next(&zvol_state_list, zv);

	mutex_enter(&zv->zv_state_lock);

	if (strcmp(zv->zv_name, oldname) == 0) {
	ops->zv_rename_minor(zv, newname);
	} else if (strncmp(zv->zv_name, oldname, oldnamelen) == 0 &&
	(zv->zv_name[oldnamelen] == '/' \|\|
	zv->zv_name[oldnamelen] == '@')) {
	char *name = kmem_asprintf("%s%c%s", newname,
	zv->zv_name[oldnamelen],
	zv->zv_name + oldnamelen + 1);
	ops->zv_rename_minor(zv, name);
	kmem_strfree(name);
	}

	mutex_exit(&zv->zv_state_lock);
	}

	rw_exit(&zvol_state_lock);
	}

	typedef struct zvol_snapdev_cb_arg {
	uint64_t snapdev;
	} zvol_snapdev_cb_arg_t;

	static int
	zvol_set_snapdev_cb(const char dsname, void param)
	{
	zvol_snapdev_cb_arg_t *arg = param;

	if (strchr(dsname, '@') == NULL)
	return (0);

	switch (arg->snapdev) {
	case ZFS_SNAPDEV_VISIBLE:
	(void) ops->zv_create_minor(dsname);
	break;
	case ZFS_SNAPDEV_HIDDEN:
	(void) zvol_remove_minor_impl(dsname);
	break;
	}

	return (0);
	}

	static void
	zvol_set_snapdev_impl(char *name, uint64_t snapdev)
	{
	zvol_snapdev_cb_arg_t arg = {snapdev};
	fstrans_cookie_t cookie = spl_fstrans_mark();
	/*
	* The zvol_set_snapdev_sync() sets snapdev appropriately
	* in the dataset hierarchy. Here, we only scan snapshots.
	*/
	dmu_objset_find(name, zvol_set_snapdev_cb, &arg, DS_FIND_SNAPSHOTS);
	spl_fstrans_unmark(cookie);
	}

	typedef struct zvol_volmode_cb_arg {
	uint64_t volmode;
	} zvol_volmode_cb_arg_t;

	static void
	zvol_set_volmode_impl(char *name, uint64_t volmode)
	{
	fstrans_cookie_t cookie;
	uint64_t old_volmode;
	zvol_state_t *zv;

	if (strchr(name, '@') != NULL)
	return;

	/*
	* It's unfortunate we need to remove minors before we create new ones:
	* this is necessary because our backing gendisk (zvol_state->zv_disk)
	* could be different when we set, for instance, volmode from "geom"
	* to "dev" (or vice versa).
	*/
	zv = zvol_find_by_name(name, RW_NONE);
	if (zv == NULL && volmode == ZFS_VOLMODE_NONE)
	return;
	if (zv != NULL) {
	old_volmode = zv->zv_volmode;
	mutex_exit(&zv->zv_state_lock);
	if (old_volmode == volmode)
	return;
	zvol_wait_close(zv);
	}
	cookie = spl_fstrans_mark();
	switch (volmode) {
	case ZFS_VOLMODE_NONE:
	(void) zvol_remove_minor_impl(name);
	break;
	case ZFS_VOLMODE_GEOM:
	case ZFS_VOLMODE_DEV:
	(void) zvol_remove_minor_impl(name);
	(void) ops->zv_create_minor(name);
	break;
	case ZFS_VOLMODE_DEFAULT:
	(void) zvol_remove_minor_impl(name);
	if (zvol_volmode == ZFS_VOLMODE_NONE)
	break;
	else /* if zvol_volmode is invalid defaults to "geom" */
	(void) ops->zv_create_minor(name);
	break;
	}
	spl_fstrans_unmark(cookie);
	}

	static zvol_task_t *
	zvol_task_alloc(zvol_async_op_t op, const char name1, const char name2,
	uint64_t value)
	{
	zvol_task_t *task;

	/* Never allow tasks on hidden names. */
	if (name1[0] == '$')
	return (NULL);

	task = kmem_zalloc(sizeof (zvol_task_t), KM_SLEEP);
	task->op = op;
	task->value = value;

	strlcpy(task->name1, name1, MAXNAMELEN);
	if (name2 != NULL)
	strlcpy(task->name2, name2, MAXNAMELEN);

	return (task);
	}

	static void
	zvol_task_free(zvol_task_t *task)
	{
	kmem_free(task, sizeof (zvol_task_t));
	}

	/*
	* The worker thread function performed asynchronously.
	*/
	static void
	zvol_task_cb(void *arg)
	{
	zvol_task_t *task = arg;

	switch (task->op) {
	case ZVOL_ASYNC_REMOVE_MINORS:
	zvol_remove_minors_impl(task->name1);
	break;
	case ZVOL_ASYNC_RENAME_MINORS:
	zvol_rename_minors_impl(task->name1, task->name2);
	break;
	case ZVOL_ASYNC_SET_SNAPDEV:
	zvol_set_snapdev_impl(task->name1, task->value);
	break;
	case ZVOL_ASYNC_SET_VOLMODE:
	zvol_set_volmode_impl(task->name1, task->value);
	break;
	default:
	VERIFY(0);
	break;
	}

	zvol_task_free(task);
	}

	typedef struct zvol_set_prop_int_arg {
	const char *zsda_name;
	uint64_t zsda_value;
	zprop_source_t zsda_source;
	dmu_tx_t *zsda_tx;
	} zvol_set_prop_int_arg_t;

	/*
	* Sanity check the dataset for safe use by the sync task. No additional
	* conditions are imposed.
	*/
	static int
	zvol_set_snapdev_check(void arg, dmu_tx_t tx)
	{
	zvol_set_prop_int_arg_t *zsda = arg;
	dsl_pool_t *dp = dmu_tx_pool(tx);
	dsl_dir_t *dd;
	int error;

	error = dsl_dir_hold(dp, zsda->zsda_name, FTAG, &dd, NULL);
	if (error != 0)
	return (error);

	dsl_dir_rele(dd, FTAG);

	return (error);
	}

	/* ARGSUSED */
	static int
	zvol_set_snapdev_sync_cb(dsl_pool_t dp, dsl_dataset_t ds, void *arg)
	{
	char dsname[MAXNAMELEN];
	zvol_task_t *task;
	uint64_t snapdev;

	dsl_dataset_name(ds, dsname);
	if (dsl_prop_get_int_ds(ds, "snapdev", &snapdev) != 0)
	return (0);
	task = zvol_task_alloc(ZVOL_ASYNC_SET_SNAPDEV, dsname, NULL, snapdev);
	if (task == NULL)
	return (0);

	(void) taskq_dispatch(dp->dp_spa->spa_zvol_taskq, zvol_task_cb,
	task, TQ_SLEEP);
	return (0);
	}

	/*
	* Traverse all child datasets and apply snapdev appropriately.
	* We call dsl_prop_set_sync_impl() here to set the value only on the toplevel
	* dataset and read the effective "snapdev" on every child in the callback
	* function: this is because the value is not guaranteed to be the same in the
	* whole dataset hierarchy.
	*/
	static void
	zvol_set_snapdev_sync(void arg, dmu_tx_t tx)
	{
	zvol_set_prop_int_arg_t *zsda = arg;
	dsl_pool_t *dp = dmu_tx_pool(tx);
	dsl_dir_t *dd;
	dsl_dataset_t *ds;
	int error;

	VERIFY0(dsl_dir_hold(dp, zsda->zsda_name, FTAG, &dd, NULL));
	zsda->zsda_tx = tx;

	error = dsl_dataset_hold(dp, zsda->zsda_name, FTAG, &ds);
	if (error == 0) {
	dsl_prop_set_sync_impl(ds, zfs_prop_to_name(ZFS_PROP_SNAPDEV),
	zsda->zsda_source, sizeof (zsda->zsda_value), 1,
	&zsda->zsda_value, zsda->zsda_tx);
	dsl_dataset_rele(ds, FTAG);
	}
	dmu_objset_find_dp(dp, dd->dd_object, zvol_set_snapdev_sync_cb,
	zsda, DS_FIND_CHILDREN);

	dsl_dir_rele(dd, FTAG);
	}

	int
	zvol_set_snapdev(const char *ddname, zprop_source_t source, uint64_t snapdev)
	{
	zvol_set_prop_int_arg_t zsda;

	zsda.zsda_name = ddname;
	zsda.zsda_source = source;
	zsda.zsda_value = snapdev;

	return (dsl_sync_task(ddname, zvol_set_snapdev_check,
	zvol_set_snapdev_sync, &zsda, 0, ZFS_SPACE_CHECK_NONE));
	}

	/*
	* Sanity check the dataset for safe use by the sync task. No additional
	* conditions are imposed.
	*/
	static int
	zvol_set_volmode_check(void arg, dmu_tx_t tx)
	{
	zvol_set_prop_int_arg_t *zsda = arg;
	dsl_pool_t *dp = dmu_tx_pool(tx);
	dsl_dir_t *dd;
	int error;

	error = dsl_dir_hold(dp, zsda->zsda_name, FTAG, &dd, NULL);
	if (error != 0)
	return (error);

	dsl_dir_rele(dd, FTAG);

	return (error);
	}

	/* ARGSUSED */
	static int
	zvol_set_volmode_sync_cb(dsl_pool_t dp, dsl_dataset_t ds, void *arg)
	{
	char dsname[MAXNAMELEN];
	zvol_task_t *task;
	uint64_t volmode;

	dsl_dataset_name(ds, dsname);
	if (dsl_prop_get_int_ds(ds, "volmode", &volmode) != 0)
	return (0);
	task = zvol_task_alloc(ZVOL_ASYNC_SET_VOLMODE, dsname, NULL, volmode);
	if (task == NULL)
	return (0);

	(void) taskq_dispatch(dp->dp_spa->spa_zvol_taskq, zvol_task_cb,
	task, TQ_SLEEP);
	return (0);
	}

	/*
	* Traverse all child datasets and apply volmode appropriately.
	* We call dsl_prop_set_sync_impl() here to set the value only on the toplevel
	* dataset and read the effective "volmode" on every child in the callback
	* function: this is because the value is not guaranteed to be the same in the
	* whole dataset hierarchy.
	*/
	static void
	zvol_set_volmode_sync(void arg, dmu_tx_t tx)
	{
	zvol_set_prop_int_arg_t *zsda = arg;
	dsl_pool_t *dp = dmu_tx_pool(tx);
	dsl_dir_t *dd;
	dsl_dataset_t *ds;
	int error;

	VERIFY0(dsl_dir_hold(dp, zsda->zsda_name, FTAG, &dd, NULL));
	zsda->zsda_tx = tx;

	error = dsl_dataset_hold(dp, zsda->zsda_name, FTAG, &ds);
	if (error == 0) {
	dsl_prop_set_sync_impl(ds, zfs_prop_to_name(ZFS_PROP_VOLMODE),
	zsda->zsda_source, sizeof (zsda->zsda_value), 1,
	&zsda->zsda_value, zsda->zsda_tx);
	dsl_dataset_rele(ds, FTAG);
	}

	dmu_objset_find_dp(dp, dd->dd_object, zvol_set_volmode_sync_cb,
	zsda, DS_FIND_CHILDREN);

	dsl_dir_rele(dd, FTAG);
	}

	int
	zvol_set_volmode(const char *ddname, zprop_source_t source, uint64_t volmode)
	{
	zvol_set_prop_int_arg_t zsda;

	zsda.zsda_name = ddname;
	zsda.zsda_source = source;
	zsda.zsda_value = volmode;

	return (dsl_sync_task(ddname, zvol_set_volmode_check,
	zvol_set_volmode_sync, &zsda, 0, ZFS_SPACE_CHECK_NONE));
	}

	void
	zvol_remove_minors(spa_t spa, const char name, boolean_t async)
	{
	zvol_task_t *task;
	taskqid_t id;

	task = zvol_task_alloc(ZVOL_ASYNC_REMOVE_MINORS, name, NULL, ~0ULL);
	if (task == NULL)
	return;

	id = taskq_dispatch(spa->spa_zvol_taskq, zvol_task_cb, task, TQ_SLEEP);
	if ((async == B_FALSE) && (id != TASKQID_INVALID))
	taskq_wait_id(spa->spa_zvol_taskq, id);
	}

	void
	zvol_rename_minors(spa_t spa, const char name1, const char *name2,
	boolean_t async)
	{
	zvol_task_t *task;
	taskqid_t id;

	task = zvol_task_alloc(ZVOL_ASYNC_RENAME_MINORS, name1, name2, ~0ULL);
	if (task == NULL)
	return;

	id = taskq_dispatch(spa->spa_zvol_taskq, zvol_task_cb, task, TQ_SLEEP);
	if ((async == B_FALSE) && (id != TASKQID_INVALID))
	taskq_wait_id(spa->spa_zvol_taskq, id);
	}

	boolean_t
	zvol_is_zvol(const char *name)
	{

	return (ops->zv_is_zvol(name));
	}

	void
	zvol_register_ops(const zvol_platform_ops_t *zvol_ops)
	{
	ops = zvol_ops;
	}

	int
	zvol_init_impl(void)
	{
	int i;

	list_create(&zvol_state_list, sizeof (zvol_state_t),
	offsetof(zvol_state_t, zv_next));
	rw_init(&zvol_state_lock, NULL, RW_DEFAULT, NULL);

	zvol_htable = kmem_alloc(ZVOL_HT_SIZE * sizeof (struct hlist_head),
	KM_SLEEP);
	for (i = 0; i < ZVOL_HT_SIZE; i++)
	INIT_HLIST_HEAD(&zvol_htable[i]);

	return (0);
	}

	void
	zvol_fini_impl(void)
	{
	zvol_remove_minors_impl(NULL);

	/*
	* The call to "zvol_remove_minors_impl" may dispatch entries to
	* the system_taskq, but it doesn't wait for those entries to
	* complete before it returns. Thus, we must wait for all of the
	* removals to finish, before we can continue.
	*/
	taskq_wait_outstanding(system_taskq, 0);

	kmem_free(zvol_htable, ZVOL_HT_SIZE * sizeof (struct hlist_head));
	list_destroy(&zvol_state_list);
	rw_destroy(&zvol_state_lock);
	}
	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 71adc78040fb..339713590f96 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,461 @@
	/*
	* 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
	* 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_isError zfs_ZSTD_isError
	#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/lib/zstd.c b/sys/contrib/openzfs/module/zstd/lib/zstd.c
	index acdd4d9dac9d..2766e5b74f55 100644
	--- a/sys/contrib/openzfs/module/zstd/lib/zstd.c
	+++ b/sys/contrib/openzfs/module/zstd/lib/zstd.c
	@@ -1,27826 +1,27824 @@
	/*
	* BSD 3-Clause Clear License
	*
	* 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-2020, Yann Collet, Facebook, Inc. All rights reserved.
	* Copyright (c) 2019-2020, Michael Niewöhner. All rights reserved.
	*/

	#define MEM_MODULE
	#define XXH_NAMESPACE ZSTD_
	#define XXH_PRIVATE_API
	#define XXH_INLINE_ALL
	#define ZSTD_LEGACY_SUPPORT 0
	#define ZSTD_LIB_DICTBUILDER 0
	#define ZSTD_LIB_DEPRECATED 0
	#define ZSTD_NOBENCH

	/** start inlining common/debug.c **/
	/* ******************************************************************
	* debug
	* Part of FSE library
	* Copyright (c) 2013-2020, Yann Collet, Facebook, Inc.
	*
	* You can contact the author at :
	* - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
	*
	* This source code is licensed under both the BSD-style license (found in the
	* LICENSE file in the root directory of this source tree) and the GPLv2 (found
	* in the COPYING file in the root directory of this source tree).
	* You may select, at your option, one of the above-listed licenses.
	****************************************************************** */


	/*
	* This module only hosts one global variable
	* which can be used to dynamically influence the verbosity of traces,
	* such as DEBUGLOG and RAWLOG
	*/

	/** start inlining debug.h **/
	/* ******************************************************************
	* debug
	* Part of FSE library
	* Copyright (c) 2013-2020, Yann Collet, Facebook, Inc.
	*
	* You can contact the author at :
	* - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
	*
	* This source code is licensed under both the BSD-style license (found in the
	* LICENSE file in the root directory of this source tree) and the GPLv2 (found
	* in the COPYING file in the root directory of this source tree).
	* You may select, at your option, one of the above-listed licenses.
	****************************************************************** */


	/*
	* The purpose of this header is to enable debug functions.
	* They regroup assert(), DEBUGLOG() and RAWLOG() for run-time,
	* and DEBUG_STATIC_ASSERT() for compile-time.
	*
	* By default, DEBUGLEVEL==0, which means run-time debug is disabled.
	*
	* Level 1 enables assert() only.
	* Starting level 2, traces can be generated and pushed to stderr.
	* The higher the level, the more verbose the traces.
	*
	* It's possible to dynamically adjust level using variable g_debug_level,
	* which is only declared if DEBUGLEVEL>=2,
	* and is a global variable, not multi-thread protected (use with care)
	*/

	#ifndef DEBUG_H_12987983217
	#define DEBUG_H_12987983217

	#if defined (__cplusplus)
	extern "C" {
	#endif


	/* static assert is triggered at compile time, leaving no runtime artefact.
	* static assert only works with compile-time constants.
	* Also, this variant can only be used inside a function. */
	#define DEBUG_STATIC_ASSERT(c) (void)sizeof(char[(c) ? 1 : -1])


	/* DEBUGLEVEL is expected to be defined externally,
	* typically through compiler command line.
	* Value must be a number. */
	#ifndef DEBUGLEVEL
	# define DEBUGLEVEL 0
	#endif


	/* DEBUGFILE can be defined externally,
	* typically through compiler command line.
	* note : currently useless.
	* Value must be stderr or stdout */
	#ifndef DEBUGFILE
	# define DEBUGFILE stderr
	#endif


	/* recommended values for DEBUGLEVEL :
	* 0 : release mode, no debug, all run-time checks disabled
	* 1 : enables assert() only, no display
	* 2 : reserved, for currently active debug path
	* 3 : events once per object lifetime (CCtx, CDict, etc.)
	* 4 : events once per frame
	* 5 : events once per block
	* 6 : events once per sequence (verbose)
	* 7+: events at every position (very verbose)
	*
	* It's generally inconvenient to output traces > 5.
	* In which case, it's possible to selectively trigger high verbosity levels
	* by modifying g_debug_level.
	*/

	#if (DEBUGLEVEL>=1)
	# include <assert.h>
	#else
	# ifndef assert /* assert may be already defined, due to prior #include <assert.h> */
	# define assert(condition) ((void)0) /* disable assert (default) */
	# endif
	#endif

	#if (DEBUGLEVEL>=2)
	# include <stdio.h>
	extern int g_debuglevel; /* the variable is only declared,
	it actually lives in debug.c,
	and is shared by the whole process.
	It's not thread-safe.
	It's useful when enabling very verbose levels
	on selective conditions (such as position in src) */

	# define RAWLOG(l, ...) { \
	if (l<=g_debuglevel) { \
	fprintf(stderr, __VA_ARGS__); \
	} }
	# define DEBUGLOG(l, ...) { \
	if (l<=g_debuglevel) { \
	fprintf(stderr, __FILE__ ": " __VA_ARGS__); \
	fprintf(stderr, " \n"); \
	} }
	#else
	# define RAWLOG(l, ...) {} /* disabled */
	# define DEBUGLOG(l, ...) {} /* disabled */
	#endif


	#if defined (__cplusplus)
	}
	#endif

	#endif /* DEBUG_H_12987983217 */
	/** ended inlining debug.h **/

	int g_debuglevel = DEBUGLEVEL;
	/** ended inlining common/debug.c **/
	/** start inlining common/entropy_common.c **/
	/* ******************************************************************
	* Common functions of New Generation Entropy library
	* Copyright (c) 2016-2020, Yann Collet, Facebook, Inc.
	*
	* You can contact the author at :
	* - FSE+HUF source repository : https://github.com/Cyan4973/FiniteStateEntropy
	* - Public forum : https://groups.google.com/forum/#!forum/lz4c
	*
	* This source code is licensed under both the BSD-style license (found in the
	* LICENSE file in the root directory of this source tree) and the GPLv2 (found
	* in the COPYING file in the root directory of this source tree).
	* You may select, at your option, one of the above-listed licenses.
	****************************************************************** */

	/* *************************************
	* Dependencies
	***************************************/
	/** start inlining mem.h **/
	/*
	* Copyright (c) 2016-2020, Yann Collet, Facebook, Inc.
	* All rights reserved.
	*
	* This source code is licensed under both the BSD-style license (found in the
	* LICENSE file in the root directory of this source tree) and the GPLv2 (found
	* in the COPYING file in the root directory of this source tree).
	* You may select, at your option, one of the above-listed licenses.
	*/

	#ifndef MEM_H_MODULE
	#define MEM_H_MODULE

	#if defined (__cplusplus)
	extern "C" {
	#endif

	/-***************************************
	* Dependencies
	******************************************/
	#include <stddef.h> /* size_t, ptrdiff_t */
	#include <string.h> /* memcpy */


	/-***************************************
	* Compiler specifics
	******************************************/
	#if defined(_MSC_VER) /* Visual Studio */
	# include <stdlib.h> /* _byteswap_ulong */
	# include <intrin.h> /* _byteswap_* */
	#endif
	#if defined(__GNUC__)
	# define MEM_STATIC static __inline __attribute__((unused))
	#elif defined (__cplusplus) \|\| (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
	# define MEM_STATIC static inline
	#elif defined(_MSC_VER)
	# define MEM_STATIC static __inline
	#else
	# define MEM_STATIC static /* this version may generate warnings for unused static functions; disable the relevant warning */
	#endif

	#ifndef __has_builtin
	# define __has_builtin(x) 0 /* compat. with non-clang compilers */
	#endif

	/* code only tested on 32 and 64 bits systems */
	#define MEM_STATIC_ASSERT(c) { enum { MEM_static_assert = 1/(int)(!!(c)) }; }
	MEM_STATIC void MEM_check(void) { MEM_STATIC_ASSERT((sizeof(size_t)==4) \|\| (sizeof(size_t)==8)); }

	/* detects whether we are being compiled under msan */
	#if defined (__has_feature)
	# if __has_feature(memory_sanitizer)
	# define MEMORY_SANITIZER 1
	# endif
	#endif

	#if defined (MEMORY_SANITIZER)
	/* Not all platforms that support msan provide sanitizers/msan_interface.h.
	* We therefore declare the functions we need ourselves, rather than trying to
	* include the header file... */

	#include <stdint.h> /* intptr_t */

	/* Make memory region fully initialized (without changing its contents). */
	void __msan_unpoison(const volatile void *a, size_t size);

	/* Make memory region fully uninitialized (without changing its contents).
	This is a legacy interface that does not update origin information. Use
	__msan_allocated_memory() instead. */
	void __msan_poison(const volatile void *a, size_t size);

	/* Returns the offset of the first (at least partially) poisoned byte in the
	memory range, or -1 if the whole range is good. */
	intptr_t __msan_test_shadow(const volatile void *x, size_t size);
	#endif

	/* detects whether we are being compiled under asan */
	#if defined (__has_feature)
	# if __has_feature(address_sanitizer)
	# define ADDRESS_SANITIZER 1
	# endif
	#elif defined(__SANITIZE_ADDRESS__)
	# define ADDRESS_SANITIZER 1
	#endif

	#if defined (ADDRESS_SANITIZER)
	/* Not all platforms that support asan provide sanitizers/asan_interface.h.
	* We therefore declare the functions we need ourselves, rather than trying to
	* include the header file... */

	/**
	* Marks a memory region (<c>[addr, addr+size)</c>) as unaddressable.
	*
	* This memory must be previously allocated by your program. Instrumented
	* code is forbidden from accessing addresses in this region until it is
	* unpoisoned. This function is not guaranteed to poison the entire region -
	* it could poison only a subregion of <c>[addr, addr+size)</c> due to ASan
	* alignment restrictions.
	*
	* \note This function is not thread-safe because no two threads can poison or
	* unpoison memory in the same memory region simultaneously.
	*
	* \param addr Start of memory region.
	* \param size Size of memory region. */
	void __asan_poison_memory_region(void const volatile *addr, size_t size);

	/**
	* Marks a memory region (<c>[addr, addr+size)</c>) as addressable.
	*
	* This memory must be previously allocated by your program. Accessing
	* addresses in this region is allowed until this region is poisoned again.
	* This function could unpoison a super-region of <c>[addr, addr+size)</c> due
	* to ASan alignment restrictions.
	*
	* \note This function is not thread-safe because no two threads can
	* poison or unpoison memory in the same memory region simultaneously.
	*
	* \param addr Start of memory region.
	* \param size Size of memory region. */
	void __asan_unpoison_memory_region(void const volatile *addr, size_t size);
	#endif


	/-*************************************************************
	* Basic Types
	*****************************************************************/
	#if !defined (__VMS) && (defined (__cplusplus) \|\| (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) )
	# include <stdint.h>
	typedef uint8_t BYTE;
	typedef uint16_t U16;
	typedef int16_t S16;
	typedef uint32_t U32;
	typedef int32_t S32;
	typedef uint64_t U64;
	typedef int64_t S64;
	#else
	# include <limits.h>
	#if CHAR_BIT != 8
	# error "this implementation requires char to be exactly 8-bit type"
	#endif
	typedef unsigned char BYTE;
	#if USHRT_MAX != 65535
	# error "this implementation requires short to be exactly 16-bit type"
	#endif
	typedef unsigned short U16;
	typedef signed short S16;
	#if UINT_MAX != 4294967295
	# error "this implementation requires int to be exactly 32-bit type"
	#endif
	typedef unsigned int U32;
	typedef signed int S32;
	/* note : there are no limits defined for long long type in C90.
	* limits exist in C99, however, in such case, <stdint.h> is preferred */
	typedef unsigned long long U64;
	typedef signed long long S64;
	#endif


	/-*************************************************************
	* Memory I/O
	*****************************************************************/
	/* MEM_FORCE_MEMORY_ACCESS :
	* By default, access to unaligned memory is controlled by `memcpy()`, which is safe and portable.
	* Unfortunately, on some target/compiler combinations, the generated assembly is sub-optimal.
	* The below switch allow to select different access method for improved performance.
	* Method 0 (default) : use `memcpy()`. Safe and portable.
	* Method 1 : `__packed` statement. It depends on compiler extension (i.e., not portable).
	* This method is safe if your compiler supports it, and generally as fast or faster than `memcpy`.
	* Method 2 : direct access. This method is portable but violate C standard.
	* It can generate buggy code on targets depending on alignment.
	* In some circumstances, it's the only known way to get the most performance (i.e. GCC + ARMv6)
	* See http://fastcompression.blogspot.fr/2015/08/accessing-unaligned-memory.html for details.
	* Prefer these methods in priority order (0 > 1 > 2)
	*/
	#ifndef MEM_FORCE_MEMORY_ACCESS /* can be defined externally, on command line for example */
	# if defined(__GNUC__) && ( defined(__ARM_ARCH_6__) \|\| defined(__ARM_ARCH_6J__) \|\| defined(__ARM_ARCH_6K__) \|\| defined(__ARM_ARCH_6Z__) \|\| defined(__ARM_ARCH_6ZK__) \|\| defined(__ARM_ARCH_6T2__) )
	# define MEM_FORCE_MEMORY_ACCESS 2
	# elif defined(__INTEL_COMPILER) \|\| defined(__GNUC__) \|\| defined(__ICCARM__)
	# define MEM_FORCE_MEMORY_ACCESS 1
	# endif
	#endif

	MEM_STATIC unsigned MEM_32bits(void) { return sizeof(size_t)==4; }
	MEM_STATIC unsigned MEM_64bits(void) { return sizeof(size_t)==8; }

	MEM_STATIC unsigned MEM_isLittleEndian(void)
	{
	const union { U32 u; BYTE c[4]; } one = { 1 }; /* don't use static : performance detrimental */
	return one.c[0];
	}

	#if defined(MEM_FORCE_MEMORY_ACCESS) && (MEM_FORCE_MEMORY_ACCESS==2)

	/* violates C standard, by lying on structure alignment.
	Only use if no other choice to achieve best performance on target platform */
	MEM_STATIC U16 MEM_read16(const void* memPtr) { return (const U16) memPtr; }
	MEM_STATIC U32 MEM_read32(const void* memPtr) { return (const U32) memPtr; }
	MEM_STATIC U64 MEM_read64(const void* memPtr) { return (const U64) memPtr; }
	MEM_STATIC size_t MEM_readST(const void* memPtr) { return (const size_t) memPtr; }

	MEM_STATIC void MEM_write16(void* memPtr, U16 value) { (U16)memPtr = value; }
	MEM_STATIC void MEM_write32(void* memPtr, U32 value) { (U32)memPtr = value; }
	MEM_STATIC void MEM_write64(void* memPtr, U64 value) { (U64)memPtr = value; }

	#elif defined(MEM_FORCE_MEMORY_ACCESS) && (MEM_FORCE_MEMORY_ACCESS==1)

	/* __pack instructions are safer, but compiler specific, hence potentially problematic for some compilers */
	/* currently only defined for gcc and icc */
	#if defined(_MSC_VER) \|\| (defined(__INTEL_COMPILER) && defined(WIN32))
	__pragma( pack(push, 1) )
	typedef struct { U16 v; } unalign16;
	typedef struct { U32 v; } unalign32;
	typedef struct { U64 v; } unalign64;
	typedef struct { size_t v; } unalignArch;
	__pragma( pack(pop) )
	#else
	typedef struct { U16 v; } __attribute__((packed)) unalign16;
	typedef struct { U32 v; } __attribute__((packed)) unalign32;
	typedef struct { U64 v; } __attribute__((packed)) unalign64;
	typedef struct { size_t v; } __attribute__((packed)) unalignArch;
	#endif

	MEM_STATIC U16 MEM_read16(const void* ptr) { return ((const unalign16*)ptr)->v; }
	MEM_STATIC U32 MEM_read32(const void* ptr) { return ((const unalign32*)ptr)->v; }
	MEM_STATIC U64 MEM_read64(const void* ptr) { return ((const unalign64*)ptr)->v; }
	MEM_STATIC size_t MEM_readST(const void* ptr) { return ((const unalignArch*)ptr)->v; }

	MEM_STATIC void MEM_write16(void* memPtr, U16 value) { ((unalign16*)memPtr)->v = value; }
	MEM_STATIC void MEM_write32(void* memPtr, U32 value) { ((unalign32*)memPtr)->v = value; }
	MEM_STATIC void MEM_write64(void* memPtr, U64 value) { ((unalign64*)memPtr)->v = value; }

	#else

	/* default method, safe and standard.
	can sometimes prove slower */

	MEM_STATIC U16 MEM_read16(const void* memPtr)
	{
	U16 val; memcpy(&val, memPtr, sizeof(val)); return val;
	}

	MEM_STATIC U32 MEM_read32(const void* memPtr)
	{
	U32 val; memcpy(&val, memPtr, sizeof(val)); return val;
	}

	MEM_STATIC U64 MEM_read64(const void* memPtr)
	{
	U64 val; memcpy(&val, memPtr, sizeof(val)); return val;
	}

	MEM_STATIC size_t MEM_readST(const void* memPtr)
	{
	size_t val; memcpy(&val, memPtr, sizeof(val)); return val;
	}

	MEM_STATIC void MEM_write16(void* memPtr, U16 value)
	{
	memcpy(memPtr, &value, sizeof(value));
	}

	MEM_STATIC void MEM_write32(void* memPtr, U32 value)
	{
	memcpy(memPtr, &value, sizeof(value));
	}

	MEM_STATIC void MEM_write64(void* memPtr, U64 value)
	{
	memcpy(memPtr, &value, sizeof(value));
	}

	#endif /* MEM_FORCE_MEMORY_ACCESS */

	MEM_STATIC U32 MEM_swap32(U32 in)
	{
	#if defined(_MSC_VER) /* Visual Studio */
	return _byteswap_ulong(in);
	#elif (defined (__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 403)) \
	\|\| (defined(__clang__) && __has_builtin(__builtin_bswap32))
	return __builtin_bswap32(in);
	#else
	return ((in << 24) & 0xff000000 ) \|
	((in << 8) & 0x00ff0000 ) \|
	((in >> 8) & 0x0000ff00 ) \|
	((in >> 24) & 0x000000ff );
	#endif
	}

	MEM_STATIC U64 MEM_swap64(U64 in)
	{
	#if defined(_MSC_VER) /* Visual Studio */
	return _byteswap_uint64(in);
	#elif (defined (__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 403)) \
	\|\| (defined(__clang__) && __has_builtin(__builtin_bswap64))
	return __builtin_bswap64(in);
	#else
	return ((in << 56) & 0xff00000000000000ULL) \|
	((in << 40) & 0x00ff000000000000ULL) \|
	((in << 24) & 0x0000ff0000000000ULL) \|
	((in << 8) & 0x000000ff00000000ULL) \|
	((in >> 8) & 0x00000000ff000000ULL) \|
	((in >> 24) & 0x0000000000ff0000ULL) \|
	((in >> 40) & 0x000000000000ff00ULL) \|
	((in >> 56) & 0x00000000000000ffULL);
	#endif
	}

	MEM_STATIC size_t MEM_swapST(size_t in)
	{
	if (MEM_32bits())
	return (size_t)MEM_swap32((U32)in);
	else
	return (size_t)MEM_swap64((U64)in);
	}

	/=== Little endian r/w ===/

	MEM_STATIC U16 MEM_readLE16(const void* memPtr)
	{
	if (MEM_isLittleEndian())
	return MEM_read16(memPtr);
	else {
	const BYTE* p = (const BYTE*)memPtr;
	return (U16)(p[0] + (p[1]<<8));
	}
	}

	MEM_STATIC void MEM_writeLE16(void* memPtr, U16 val)
	{
	if (MEM_isLittleEndian()) {
	MEM_write16(memPtr, val);
	} else {
	BYTE* p = (BYTE*)memPtr;
	p[0] = (BYTE)val;
	p[1] = (BYTE)(val>>8);
	}
	}

	MEM_STATIC U32 MEM_readLE24(const void* memPtr)
	{
	return MEM_readLE16(memPtr) + (((const BYTE*)memPtr)[2] << 16);
	}

	MEM_STATIC void MEM_writeLE24(void* memPtr, U32 val)
	{
	MEM_writeLE16(memPtr, (U16)val);
	((BYTE*)memPtr)[2] = (BYTE)(val>>16);
	}

	MEM_STATIC U32 MEM_readLE32(const void* memPtr)
	{
	if (MEM_isLittleEndian())
	return MEM_read32(memPtr);
	else
	return MEM_swap32(MEM_read32(memPtr));
	}

	MEM_STATIC void MEM_writeLE32(void* memPtr, U32 val32)
	{
	if (MEM_isLittleEndian())
	MEM_write32(memPtr, val32);
	else
	MEM_write32(memPtr, MEM_swap32(val32));
	}

	MEM_STATIC U64 MEM_readLE64(const void* memPtr)
	{
	if (MEM_isLittleEndian())
	return MEM_read64(memPtr);
	else
	return MEM_swap64(MEM_read64(memPtr));
	}

	MEM_STATIC void MEM_writeLE64(void* memPtr, U64 val64)
	{
	if (MEM_isLittleEndian())
	MEM_write64(memPtr, val64);
	else
	MEM_write64(memPtr, MEM_swap64(val64));
	}

	MEM_STATIC size_t MEM_readLEST(const void* memPtr)
	{
	if (MEM_32bits())
	return (size_t)MEM_readLE32(memPtr);
	else
	return (size_t)MEM_readLE64(memPtr);
	}

	MEM_STATIC void MEM_writeLEST(void* memPtr, size_t val)
	{
	if (MEM_32bits())
	MEM_writeLE32(memPtr, (U32)val);
	else
	MEM_writeLE64(memPtr, (U64)val);
	}

	/=== Big endian r/w ===/

	MEM_STATIC U32 MEM_readBE32(const void* memPtr)
	{
	if (MEM_isLittleEndian())
	return MEM_swap32(MEM_read32(memPtr));
	else
	return MEM_read32(memPtr);
	}

	MEM_STATIC void MEM_writeBE32(void* memPtr, U32 val32)
	{
	if (MEM_isLittleEndian())
	MEM_write32(memPtr, MEM_swap32(val32));
	else
	MEM_write32(memPtr, val32);
	}

	MEM_STATIC U64 MEM_readBE64(const void* memPtr)
	{
	if (MEM_isLittleEndian())
	return MEM_swap64(MEM_read64(memPtr));
	else
	return MEM_read64(memPtr);
	}

	MEM_STATIC void MEM_writeBE64(void* memPtr, U64 val64)
	{
	if (MEM_isLittleEndian())
	MEM_write64(memPtr, MEM_swap64(val64));
	else
	MEM_write64(memPtr, val64);
	}

	MEM_STATIC size_t MEM_readBEST(const void* memPtr)
	{
	if (MEM_32bits())
	return (size_t)MEM_readBE32(memPtr);
	else
	return (size_t)MEM_readBE64(memPtr);
	}

	MEM_STATIC void MEM_writeBEST(void* memPtr, size_t val)
	{
	if (MEM_32bits())
	MEM_writeBE32(memPtr, (U32)val);
	else
	MEM_writeBE64(memPtr, (U64)val);
	}


	#if defined (__cplusplus)
	}
	#endif

	#endif /* MEM_H_MODULE */
	/** ended inlining mem.h **/
	/** start inlining error_private.h **/
	/*
	* Copyright (c) 2016-2020, Yann Collet, Facebook, Inc.
	* All rights reserved.
	*
	* This source code is licensed under both the BSD-style license (found in the
	* LICENSE file in the root directory of this source tree) and the GPLv2 (found
	* in the COPYING file in the root directory of this source tree).
	* You may select, at your option, one of the above-listed licenses.
	*/

	/* Note : this module is expected to remain private, do not expose it */

	#ifndef ERROR_H_MODULE
	#define ERROR_H_MODULE

	#if defined (__cplusplus)
	extern "C" {
	#endif


	/* ****************************************
	* Dependencies
	******************************************/
	#include <stddef.h> /* size_t */
	/** start inlining zstd_errors.h **/
	/*
	* Copyright (c) 2016-2020, Yann Collet, Facebook, Inc.
	* All rights reserved.
	*
	* This source code is licensed under both the BSD-style license (found in the
	* LICENSE file in the root directory of this source tree) and the GPLv2 (found
	* in the COPYING file in the root directory of this source tree).
	* You may select, at your option, one of the above-listed licenses.
	*/

	#ifndef ZSTD_ERRORS_H_398273423
	#define ZSTD_ERRORS_H_398273423

	#if defined (__cplusplus)
	extern "C" {
	#endif

	/===== dependency =====/
	#include <stddef.h> /* size_t */


	/* ===== ZSTDERRORLIB_API : control library symbols visibility ===== */
	#ifndef ZSTDERRORLIB_VISIBILITY
	# if defined(__GNUC__) && (__GNUC__ >= 4)
	# define ZSTDERRORLIB_VISIBILITY __attribute__ ((visibility ("default")))
	# else
	# define ZSTDERRORLIB_VISIBILITY
	# endif
	#endif
	#if defined(ZSTD_DLL_EXPORT) && (ZSTD_DLL_EXPORT==1)
	# define ZSTDERRORLIB_API __declspec(dllexport) ZSTDERRORLIB_VISIBILITY
	#elif defined(ZSTD_DLL_IMPORT) && (ZSTD_DLL_IMPORT==1)
	# define ZSTDERRORLIB_API __declspec(dllimport) ZSTDERRORLIB_VISIBILITY /* It isn't required but allows to generate better code, saving a function pointer load from the IAT and an indirect jump.*/
	#else
	# define ZSTDERRORLIB_API ZSTDERRORLIB_VISIBILITY
	#endif

	/-********************************************
	* Error codes list
	-********************************************
	* Error codes _values_ are pinned down since v1.3.1 only.
	* Therefore, don't rely on values if you may link to any version < v1.3.1.
	*
	* Only values < 100 are considered stable.
	*
	* note 1 : this API shall be used with static linking only.
	* dynamic linking is not yet officially supported.
	* note 2 : Prefer relying on the enum than on its value whenever possible
	* This is the only supported way to use the error list < v1.3.1
	* note 3 : ZSTD_isError() is always correct, whatever the library version.
	**********************************************/
	typedef enum {
	ZSTD_error_no_error = 0,
	ZSTD_error_GENERIC = 1,
	ZSTD_error_prefix_unknown = 10,
	ZSTD_error_version_unsupported = 12,
	ZSTD_error_frameParameter_unsupported = 14,
	ZSTD_error_frameParameter_windowTooLarge = 16,
	ZSTD_error_corruption_detected = 20,
	ZSTD_error_checksum_wrong = 22,
	ZSTD_error_dictionary_corrupted = 30,
	ZSTD_error_dictionary_wrong = 32,
	ZSTD_error_dictionaryCreation_failed = 34,
	ZSTD_error_parameter_unsupported = 40,
	ZSTD_error_parameter_outOfBound = 42,
	ZSTD_error_tableLog_tooLarge = 44,
	ZSTD_error_maxSymbolValue_tooLarge = 46,
	ZSTD_error_maxSymbolValue_tooSmall = 48,
	ZSTD_error_stage_wrong = 60,
	ZSTD_error_init_missing = 62,
	ZSTD_error_memory_allocation = 64,
	ZSTD_error_workSpace_tooSmall= 66,
	ZSTD_error_dstSize_tooSmall = 70,
	ZSTD_error_srcSize_wrong = 72,
	ZSTD_error_dstBuffer_null = 74,
	/* following error codes are __NOT STABLE__, they can be removed or changed in future versions */
	ZSTD_error_frameIndex_tooLarge = 100,
	ZSTD_error_seekableIO = 102,
	ZSTD_error_dstBuffer_wrong = 104,
	ZSTD_error_maxCode = 120 /* never EVER use this value directly, it can change in future versions! Use ZSTD_isError() instead */
	} ZSTD_ErrorCode;

	/*! ZSTD_getErrorCode() :
	convert a `size_t` function result into a `ZSTD_ErrorCode` enum type,
	which can be used to compare with enum list published above */
	ZSTDERRORLIB_API ZSTD_ErrorCode ZSTD_getErrorCode(size_t functionResult);
	ZSTDERRORLIB_API const char* ZSTD_getErrorString(ZSTD_ErrorCode code); /*< Same as ZSTD_getErrorName, but using a `ZSTD_ErrorCode` enum argument /


	#if defined (__cplusplus)
	}
	#endif

	#endif /* ZSTD_ERRORS_H_398273423 */
	/** ended inlining zstd_errors.h **/


	/* ****************************************
	* Compiler-specific
	******************************************/
	#if defined(__GNUC__)
	# define ERR_STATIC static __attribute__((unused))
	#elif defined (__cplusplus) \|\| (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
	# define ERR_STATIC static inline
	#elif defined(_MSC_VER)
	# define ERR_STATIC static __inline
	#else
	# define ERR_STATIC static /* this version may generate warnings for unused static functions; disable the relevant warning */
	#endif


	/-***************************************
	* Customization (error_public.h)
	******************************************/
	typedef ZSTD_ErrorCode ERR_enum;
	#define PREFIX(name) ZSTD_error_##name


	/-***************************************
	* Error codes handling
	******************************************/
	#undef ERROR /* already defined on Visual Studio */
	#define ERROR(name) ZSTD_ERROR(name)
	#define ZSTD_ERROR(name) ((size_t)-PREFIX(name))

	ERR_STATIC unsigned ERR_isError(size_t code) { return (code > ERROR(maxCode)); }

	ERR_STATIC ERR_enum ERR_getErrorCode(size_t code) { if (!ERR_isError(code)) return (ERR_enum)0; return (ERR_enum) (0-code); }

	/* check and forward error code */
	#define CHECK_V_F(e, f) size_t const e = f; if (ERR_isError(e)) return e
	#define CHECK_F(f) { CHECK_V_F(_var_err__, f); }


	/-***************************************
	* Error Strings
	******************************************/

	const char* ERR_getErrorString(ERR_enum code); /* error_private.c */

	ERR_STATIC const char* ERR_getErrorName(size_t code)
	{
	return ERR_getErrorString(ERR_getErrorCode(code));
	}

	#if defined (__cplusplus)
	}
	#endif

	#endif /* ERROR_H_MODULE */
	/** ended inlining error_private.h **/
	#define FSE_STATIC_LINKING_ONLY /* FSE_MIN_TABLELOG */
	/** start inlining fse.h **/
	/* ******************************************************************
	* FSE : Finite State Entropy codec
	* Public Prototypes declaration
	* Copyright (c) 2013-2020, Yann Collet, Facebook, Inc.
	*
	* You can contact the author at :
	* - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
	*
	* This source code is licensed under both the BSD-style license (found in the
	* LICENSE file in the root directory of this source tree) and the GPLv2 (found
	* in the COPYING file in the root directory of this source tree).
	* You may select, at your option, one of the above-listed licenses.
	****************************************************************** */

	#if defined (__cplusplus)
	extern "C" {
	#endif

	#ifndef FSE_H
	#define FSE_H


	/-****************************************
	* Dependencies
	******************************************/
	#include <stddef.h> /* size_t, ptrdiff_t */


	/-****************************************
	* FSE_PUBLIC_API : control library symbols visibility
	******************************************/
	#if defined(FSE_DLL_EXPORT) && (FSE_DLL_EXPORT==1) && defined(__GNUC__) && (__GNUC__ >= 4)
	# define FSE_PUBLIC_API __attribute__ ((visibility ("default")))
	#elif defined(FSE_DLL_EXPORT) && (FSE_DLL_EXPORT==1) /* Visual expected */
	# define FSE_PUBLIC_API __declspec(dllexport)
	#elif defined(FSE_DLL_IMPORT) && (FSE_DLL_IMPORT==1)
	# define FSE_PUBLIC_API __declspec(dllimport) /* It isn't required but allows to generate better code, saving a function pointer load from the IAT and an indirect jump.*/
	#else
	# define FSE_PUBLIC_API
	#endif

	/------ Version ------/
	#define FSE_VERSION_MAJOR 0
	#define FSE_VERSION_MINOR 9
	#define FSE_VERSION_RELEASE 0

	#define FSE_LIB_VERSION FSE_VERSION_MAJOR.FSE_VERSION_MINOR.FSE_VERSION_RELEASE
	#define FSE_QUOTE(str) #str
	#define FSE_EXPAND_AND_QUOTE(str) FSE_QUOTE(str)
	#define FSE_VERSION_STRING FSE_EXPAND_AND_QUOTE(FSE_LIB_VERSION)

	#define FSE_VERSION_NUMBER (FSE_VERSION_MAJOR 100100 + FSE_VERSION_MINOR *100 + FSE_VERSION_RELEASE)
	FSE_PUBLIC_API unsigned FSE_versionNumber(void); /*< library version number; to be used when checking dll version /


	/-***************************************
	* FSE simple functions
	******************************************/
	/*! FSE_compress() :
	Compress content of buffer 'src', of size 'srcSize', into destination buffer 'dst'.
	'dst' buffer must be already allocated. Compression runs faster is dstCapacity >= FSE_compressBound(srcSize).
	@return : size of compressed data (<= dstCapacity).
	Special values : if return == 0, srcData is not compressible => Nothing is stored within dst !!!
	if return == 1, srcData is a single byte symbol * srcSize times. Use RLE compression instead.
	if FSE_isError(return), compression failed (more details using FSE_getErrorName())
	*/
	FSE_PUBLIC_API size_t FSE_compress(void* dst, size_t dstCapacity,
	const void* src, size_t srcSize);

	/*! FSE_decompress():
	Decompress FSE data from buffer 'cSrc', of size 'cSrcSize',
	into already allocated destination buffer 'dst', of size 'dstCapacity'.
	@return : size of regenerated data (<= maxDstSize),
	or an error code, which can be tested using FSE_isError() .

	Important : FSE_decompress() does not decompress non-compressible nor RLE data !!!
	Why ? : making this distinction requires a header.
	Header management is intentionally delegated to the user layer, which can better manage special cases.
	*/
	FSE_PUBLIC_API size_t FSE_decompress(void* dst, size_t dstCapacity,
	const void* cSrc, size_t cSrcSize);


	/-****************************************
	* Tool functions
	******************************************/
	FSE_PUBLIC_API size_t FSE_compressBound(size_t size); /* maximum compressed size */

	/* Error Management */
	FSE_PUBLIC_API unsigned FSE_isError(size_t code); /* tells if a return value is an error code */
	FSE_PUBLIC_API const char* FSE_getErrorName(size_t code); /* provides error code string (useful for debugging) */


	/-****************************************
	* FSE advanced functions
	******************************************/
	/*! FSE_compress2() :
	Same as FSE_compress(), but allows the selection of 'maxSymbolValue' and 'tableLog'
	Both parameters can be defined as '0' to mean : use default value
	@return : size of compressed data
	Special values : if return == 0, srcData is not compressible => Nothing is stored within cSrc !!!
	if return == 1, srcData is a single byte symbol * srcSize times. Use RLE compression.
	if FSE_isError(return), it's an error code.
	*/
	FSE_PUBLIC_API size_t FSE_compress2 (void* dst, size_t dstSize, const void* src, size_t srcSize, unsigned maxSymbolValue, unsigned tableLog);


	/-****************************************
	* FSE detailed API
	******************************************/
	/*!
	FSE_compress() does the following:
	1. count symbol occurrence from source[] into table count[] (see hist.h)
	2. normalize counters so that sum(count[]) == Power_of_2 (2^tableLog)
	3. save normalized counters to memory buffer using writeNCount()
	4. build encoding table 'CTable' from normalized counters
	5. encode the data stream using encoding table 'CTable'

	FSE_decompress() does the following:
	1. read normalized counters with readNCount()
	2. build decoding table 'DTable' from normalized counters
	3. decode the data stream using decoding table 'DTable'

	The following API allows targeting specific sub-functions for advanced tasks.
	For example, it's possible to compress several blocks using the same 'CTable',
	or to save and provide normalized distribution using external method.
	*/

	/* * COMPRESSION * */

	/*! FSE_optimalTableLog():
	dynamically downsize 'tableLog' when conditions are met.
	It saves CPU time, by using smaller tables, while preserving or even improving compression ratio.
	@return : recommended tableLog (necessarily <= 'maxTableLog') */
	FSE_PUBLIC_API unsigned FSE_optimalTableLog(unsigned maxTableLog, size_t srcSize, unsigned maxSymbolValue);

	/*! FSE_normalizeCount():
	normalize counts so that sum(count[]) == Power_of_2 (2^tableLog)
	'normalizedCounter' is a table of short, of minimum size (maxSymbolValue+1).
	@return : tableLog,
	or an errorCode, which can be tested using FSE_isError() */
	FSE_PUBLIC_API size_t FSE_normalizeCount(short* normalizedCounter, unsigned tableLog,
	const unsigned* count, size_t srcSize, unsigned maxSymbolValue);

	/*! FSE_NCountWriteBound():
	Provides the maximum possible size of an FSE normalized table, given 'maxSymbolValue' and 'tableLog'.
	Typically useful for allocation purpose. */
	FSE_PUBLIC_API size_t FSE_NCountWriteBound(unsigned maxSymbolValue, unsigned tableLog);

	/*! FSE_writeNCount():
	Compactly save 'normalizedCounter' into 'buffer'.
	@return : size of the compressed table,
	or an errorCode, which can be tested using FSE_isError(). */
	FSE_PUBLIC_API size_t FSE_writeNCount (void* buffer, size_t bufferSize,
	const short* normalizedCounter,
	unsigned maxSymbolValue, unsigned tableLog);

	/*! Constructor and Destructor of FSE_CTable.
	Note that FSE_CTable size depends on 'tableLog' and 'maxSymbolValue' */
	typedef unsigned FSE_CTable; /* don't allocate that. It's only meant to be more restrictive than void* */
	FSE_PUBLIC_API FSE_CTable* FSE_createCTable (unsigned maxSymbolValue, unsigned tableLog);
	FSE_PUBLIC_API void FSE_freeCTable (FSE_CTable* ct);

	/*! FSE_buildCTable():
	Builds `ct`, which must be already allocated, using FSE_createCTable().
	@return : 0, or an errorCode, which can be tested using FSE_isError() */
	FSE_PUBLIC_API size_t FSE_buildCTable(FSE_CTable* ct, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog);

	/*! FSE_compress_usingCTable():
	Compress `src` using `ct` into `dst` which must be already allocated.
	@return : size of compressed data (<= `dstCapacity`),
	or 0 if compressed data could not fit into `dst`,
	or an errorCode, which can be tested using FSE_isError() */
	FSE_PUBLIC_API size_t FSE_compress_usingCTable (void* dst, size_t dstCapacity, const void* src, size_t srcSize, const FSE_CTable* ct);

	/*!
	Tutorial :
	----------
	The first step is to count all symbols. FSE_count() does this job very fast.
	Result will be saved into 'count', a table of unsigned int, which must be already allocated, and have 'maxSymbolValuePtr[0]+1' cells.
	'src' is a table of bytes of size 'srcSize'. All values within 'src' MUST be <= maxSymbolValuePtr[0]
	maxSymbolValuePtr[0] will be updated, with its real value (necessarily <= original value)
	FSE_count() will return the number of occurrence of the most frequent symbol.
	This can be used to know if there is a single symbol within 'src', and to quickly evaluate its compressibility.
	If there is an error, the function will return an ErrorCode (which can be tested using FSE_isError()).

	The next step is to normalize the frequencies.
	FSE_normalizeCount() will ensure that sum of frequencies is == 2 ^'tableLog'.
	It also guarantees a minimum of 1 to any Symbol with frequency >= 1.
	You can use 'tableLog'==0 to mean "use default tableLog value".
	If you are unsure of which tableLog value to use, you can ask FSE_optimalTableLog(),
	which will provide the optimal valid tableLog given sourceSize, maxSymbolValue, and a user-defined maximum (0 means "default").

	The result of FSE_normalizeCount() will be saved into a table,
	called 'normalizedCounter', which is a table of signed short.
	'normalizedCounter' must be already allocated, and have at least 'maxSymbolValue+1' cells.
	The return value is tableLog if everything proceeded as expected.
	It is 0 if there is a single symbol within distribution.
	If there is an error (ex: invalid tableLog value), the function will return an ErrorCode (which can be tested using FSE_isError()).

	'normalizedCounter' can be saved in a compact manner to a memory area using FSE_writeNCount().
	'buffer' must be already allocated.
	For guaranteed success, buffer size must be at least FSE_headerBound().
	The result of the function is the number of bytes written into 'buffer'.
	If there is an error, the function will return an ErrorCode (which can be tested using FSE_isError(); ex : buffer size too small).

	'normalizedCounter' can then be used to create the compression table 'CTable'.
	The space required by 'CTable' must be already allocated, using FSE_createCTable().
	You can then use FSE_buildCTable() to fill 'CTable'.
	If there is an error, both functions will return an ErrorCode (which can be tested using FSE_isError()).

	'CTable' can then be used to compress 'src', with FSE_compress_usingCTable().
	Similar to FSE_count(), the convention is that 'src' is assumed to be a table of char of size 'srcSize'
	The function returns the size of compressed data (without header), necessarily <= `dstCapacity`.
	If it returns '0', compressed data could not fit into 'dst'.
	If there is an error, the function will return an ErrorCode (which can be tested using FSE_isError()).
	*/


	/* * DECOMPRESSION * */

	/*! FSE_readNCount():
	Read compactly saved 'normalizedCounter' from 'rBuffer'.
	@return : size read from 'rBuffer',
	or an errorCode, which can be tested using FSE_isError().
	maxSymbolValuePtr[0] and tableLogPtr[0] will also be updated with their respective values */
	FSE_PUBLIC_API size_t FSE_readNCount (short* normalizedCounter,
	unsigned* maxSymbolValuePtr, unsigned* tableLogPtr,
	const void* rBuffer, size_t rBuffSize);

	/*! Constructor and Destructor of FSE_DTable.
	Note that its size depends on 'tableLog' */
	typedef unsigned FSE_DTable; /* don't allocate that. It's just a way to be more restrictive than void* */
	FSE_PUBLIC_API FSE_DTable* FSE_createDTable(unsigned tableLog);
	FSE_PUBLIC_API void FSE_freeDTable(FSE_DTable* dt);

	/*! FSE_buildDTable():
	Builds 'dt', which must be already allocated, using FSE_createDTable().
	return : 0, or an errorCode, which can be tested using FSE_isError() */
	FSE_PUBLIC_API size_t FSE_buildDTable (FSE_DTable* dt, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog);

	/*! FSE_decompress_usingDTable():
	Decompress compressed source `cSrc` of size `cSrcSize` using `dt`
	into `dst` which must be already allocated.
	@return : size of regenerated data (necessarily <= `dstCapacity`),
	or an errorCode, which can be tested using FSE_isError() */
	FSE_PUBLIC_API size_t FSE_decompress_usingDTable(void* dst, size_t dstCapacity, const void* cSrc, size_t cSrcSize, const FSE_DTable* dt);

	/*!
	Tutorial :
	----------
	(Note : these functions only decompress FSE-compressed blocks.
	If block is uncompressed, use memcpy() instead
	If block is a single repeated byte, use memset() instead )

	The first step is to obtain the normalized frequencies of symbols.
	This can be performed by FSE_readNCount() if it was saved using FSE_writeNCount().
	'normalizedCounter' must be already allocated, and have at least 'maxSymbolValuePtr[0]+1' cells of signed short.
	In practice, that means it's necessary to know 'maxSymbolValue' beforehand,
	or size the table to handle worst case situations (typically 256).
	FSE_readNCount() will provide 'tableLog' and 'maxSymbolValue'.
	The result of FSE_readNCount() is the number of bytes read from 'rBuffer'.
	Note that 'rBufferSize' must be at least 4 bytes, even if useful information is less than that.
	If there is an error, the function will return an error code, which can be tested using FSE_isError().

	The next step is to build the decompression tables 'FSE_DTable' from 'normalizedCounter'.
	This is performed by the function FSE_buildDTable().
	The space required by 'FSE_DTable' must be already allocated using FSE_createDTable().
	If there is an error, the function will return an error code, which can be tested using FSE_isError().

	`FSE_DTable` can then be used to decompress `cSrc`, with FSE_decompress_usingDTable().
	`cSrcSize` must be strictly correct, otherwise decompression will fail.
	FSE_decompress_usingDTable() result will tell how many bytes were regenerated (<=`dstCapacity`).
	If there is an error, the function will return an error code, which can be tested using FSE_isError(). (ex: dst buffer too small)
	*/

	#endif /* FSE_H */

	#if defined(FSE_STATIC_LINKING_ONLY) && !defined(FSE_H_FSE_STATIC_LINKING_ONLY)
	#define FSE_H_FSE_STATIC_LINKING_ONLY

	/* * Dependency * */
	/** start inlining bitstream.h **/
	/* ******************************************************************
	* bitstream
	* Part of FSE library
	* Copyright (c) 2013-2020, Yann Collet, Facebook, Inc.
	*
	* You can contact the author at :
	* - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
	*
	* This source code is licensed under both the BSD-style license (found in the
	* LICENSE file in the root directory of this source tree) and the GPLv2 (found
	* in the COPYING file in the root directory of this source tree).
	* You may select, at your option, one of the above-listed licenses.
	****************************************************************** */
	#ifndef BITSTREAM_H_MODULE
	#define BITSTREAM_H_MODULE

	#if defined (__cplusplus)
	extern "C" {
	#endif

	/*
	* This API consists of small unitary functions, which must be inlined for best performance.
	* Since link-time-optimization is not available for all compilers,
	* these functions are defined into a .h to be included.
	*/

	/-***************************************
	* Dependencies
	******************************************/
	/** skipping file: mem.h **/
	/** start inlining compiler.h **/
	/*
	* Copyright (c) 2016-2020, Yann Collet, Facebook, Inc.
	* All rights reserved.
	*
	* This source code is licensed under both the BSD-style license (found in the
	* LICENSE file in the root directory of this source tree) and the GPLv2 (found
	* in the COPYING file in the root directory of this source tree).
	* You may select, at your option, one of the above-listed licenses.
	*/

	#ifndef ZSTD_COMPILER_H
	#define ZSTD_COMPILER_H

	/-******************************************************
	* Compiler specifics
	*********************************************************/
	/* force inlining */

	#if !defined(ZSTD_NO_INLINE)
	#if (defined(__GNUC__) && !defined(__STRICT_ANSI__)) \|\| defined(__cplusplus) \|\| defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L /* C99 */
	# define INLINE_KEYWORD inline
	#else
	# define INLINE_KEYWORD
	#endif

	#if defined(__GNUC__) \|\| defined(__ICCARM__)
	# define FORCE_INLINE_ATTR __attribute__((always_inline))
	#elif defined(_MSC_VER)
	# define FORCE_INLINE_ATTR __forceinline
	#else
	# define FORCE_INLINE_ATTR
	#endif

	#else

	#define INLINE_KEYWORD
	#define FORCE_INLINE_ATTR

	#endif

	/**
	* FORCE_INLINE_TEMPLATE is used to define C "templates", which take constant
	* parameters. They must be inlined for the compiler to eliminate the constant
	* branches.
	*/
	#define FORCE_INLINE_TEMPLATE static INLINE_KEYWORD FORCE_INLINE_ATTR
	/**
	* HINT_INLINE is used to help the compiler generate better code. It is not
	* used for "templates", so it can be tweaked based on the compilers
	* performance.
	*
	* gcc-4.8 and gcc-4.9 have been shown to benefit from leaving off the
	* always_inline attribute.
	*
	* clang up to 5.0.0 (trunk) benefit tremendously from the always_inline
	* attribute.
	*/
	#if !defined(__clang__) && defined(__GNUC__) && __GNUC__ >= 4 && __GNUC_MINOR__ >= 8 && __GNUC__ < 5
	# define HINT_INLINE static INLINE_KEYWORD
	#else
	# define HINT_INLINE static INLINE_KEYWORD FORCE_INLINE_ATTR
	#endif

	/* UNUSED_ATTR tells the compiler it is okay if the function is unused. */
	#if defined(__GNUC__)
	# define UNUSED_ATTR __attribute__((unused))
	#else
	# define UNUSED_ATTR
	#endif

	/* force no inlining */
	#ifdef _MSC_VER
	# define FORCE_NOINLINE static __declspec(noinline)
	#else
	# if defined(__GNUC__) \|\| defined(__ICCARM__)
	# define FORCE_NOINLINE static __attribute__((__noinline__))
	# else
	# define FORCE_NOINLINE static
	# endif
	#endif

	/* target attribute */
	#ifndef __has_attribute
	#define __has_attribute(x) 0 /* Compatibility with non-clang compilers. */
	#endif
	#if defined(__GNUC__) \|\| defined(__ICCARM__)
	# define TARGET_ATTRIBUTE(target) __attribute__((__target__(target)))
	#else
	# define TARGET_ATTRIBUTE(target)
	#endif

	/* Enable runtime BMI2 dispatch based on the CPU.
	* Enabled for clang & gcc >=4.8 on x86 when BMI2 isn't enabled by default.
	*/
	#ifndef DYNAMIC_BMI2
	#if ((defined(__clang__) && __has_attribute(__target__)) \
	\|\| (defined(__GNUC__) \
	&& (__GNUC__ >= 5 \|\| (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)))) \
	&& (defined(__x86_64__) \|\| defined(_M_X86)) \
	&& !defined(__BMI2__)
	# define DYNAMIC_BMI2 1
	#else
	# define DYNAMIC_BMI2 0
	#endif
	#endif

	/* prefetch
	* can be disabled, by declaring NO_PREFETCH build macro */
	#if defined(NO_PREFETCH)
	# define PREFETCH_L1(ptr) (void)(ptr) /* disabled */
	# define PREFETCH_L2(ptr) (void)(ptr) /* disabled */
	#else
	# if defined(_MSC_VER) && (defined(_M_X64) \|\| defined(_M_I86)) /* _mm_prefetch() is not defined outside of x86/x64 */
	# include <mmintrin.h> /* https://msdn.microsoft.com/fr-fr/library/84szxsww(v=vs.90).aspx */
	# define PREFETCH_L1(ptr) _mm_prefetch((const char*)(ptr), _MM_HINT_T0)
	# define PREFETCH_L2(ptr) _mm_prefetch((const char*)(ptr), _MM_HINT_T1)
	# elif defined(__aarch64__)
	# define PREFETCH_L1(ptr) __asm__ __volatile__("prfm pldl1keep, %0" ::"Q"(*(ptr)))
	# define PREFETCH_L2(ptr) __asm__ __volatile__("prfm pldl2keep, %0" ::"Q"(*(ptr)))
	# elif defined(__GNUC__) && ( (__GNUC__ >= 4) \|\| ( (__GNUC__ == 3) && (__GNUC_MINOR__ >= 1) ) )
	# define PREFETCH_L1(ptr) __builtin_prefetch((ptr), 0 /* rw==read /, 3 / locality */)
	# define PREFETCH_L2(ptr) __builtin_prefetch((ptr), 0 /* rw==read /, 2 / locality */)
	# else
	# define PREFETCH_L1(ptr) (void)(ptr) /* disabled */
	# define PREFETCH_L2(ptr) (void)(ptr) /* disabled */
	# endif
	#endif /* NO_PREFETCH */

	#define CACHELINE_SIZE 64

	#define PREFETCH_AREA(p, s) { \
	const char* const _ptr = (const char*)(p); \
	size_t const _size = (size_t)(s); \
	size_t _pos; \
	for (_pos=0; _pos<_size; _pos+=CACHELINE_SIZE) { \
	PREFETCH_L2(_ptr + _pos); \
	} \
	}

	/* vectorization
	* older GCC (pre gcc-4.3 picked as the cutoff) uses a different syntax */
	#if !defined(__INTEL_COMPILER) && !defined(__clang__) && defined(__GNUC__)
	# if (__GNUC__ == 4 && __GNUC_MINOR__ > 3) \|\| (__GNUC__ >= 5)
	# define DONT_VECTORIZE __attribute__((optimize("no-tree-vectorize")))
	# else
	# define DONT_VECTORIZE _Pragma("GCC optimize(\"no-tree-vectorize\")")
	# endif
	#else
	# define DONT_VECTORIZE
	#endif

	/* Tell the compiler that a branch is likely or unlikely.
	* Only use these macros if it causes the compiler to generate better code.
	* If you can remove a LIKELY/UNLIKELY annotation without speed changes in gcc
	* and clang, please do.
	*/
	#if defined(__GNUC__)
	#define LIKELY(x) (__builtin_expect((x), 1))
	#define UNLIKELY(x) (__builtin_expect((x), 0))
	#else
	#define LIKELY(x) (x)
	#define UNLIKELY(x) (x)
	#endif

	/* disable warnings */
	#ifdef _MSC_VER /* Visual Studio */
	# include <intrin.h> /* For Visual 2005 */
	# pragma warning(disable : 4100) /* disable: C4100: unreferenced formal parameter */
	# pragma warning(disable : 4127) /* disable: C4127: conditional expression is constant */
	# pragma warning(disable : 4204) /* disable: C4204: non-constant aggregate initializer */
	# pragma warning(disable : 4214) /* disable: C4214: non-int bitfields */
	# pragma warning(disable : 4324) /* disable: C4324: padded structure */
	#endif

	#endif /* ZSTD_COMPILER_H */
	/** ended inlining compiler.h **/
	/** skipping file: debug.h **/
	/** skipping file: error_private.h **/


	/*=========================================
	* Target specific
	=========================================*/
	#if defined(__BMI__) && defined(__GNUC__)
	# include <immintrin.h> /* support for bextr (experimental) */
	#elif defined(__ICCARM__)
	# include <intrinsics.h>
	#endif

	#define STREAM_ACCUMULATOR_MIN_32 25
	#define STREAM_ACCUMULATOR_MIN_64 57
	#define STREAM_ACCUMULATOR_MIN ((U32)(MEM_32bits() ? STREAM_ACCUMULATOR_MIN_32 : STREAM_ACCUMULATOR_MIN_64))


	/-*****************************************
	* bitStream encoding API (write forward)
	********************************************/
	/* bitStream can mix input from multiple sources.
	* A critical property of these streams is that they encode and decode in reverse direction.
	* So the first bit sequence you add will be the last to be read, like a LIFO stack.
	*/
	typedef struct {
	size_t bitContainer;
	unsigned bitPos;
	char* startPtr;
	char* ptr;
	char* endPtr;
	} BIT_CStream_t;

	MEM_STATIC size_t BIT_initCStream(BIT_CStream_t* bitC, void* dstBuffer, size_t dstCapacity);
	MEM_STATIC void BIT_addBits(BIT_CStream_t* bitC, size_t value, unsigned nbBits);
	MEM_STATIC void BIT_flushBits(BIT_CStream_t* bitC);
	MEM_STATIC size_t BIT_closeCStream(BIT_CStream_t* bitC);

	/* Start with initCStream, providing the size of buffer to write into.
	* bitStream will never write outside of this buffer.
	* `dstCapacity` must be >= sizeof(bitD->bitContainer), otherwise @return will be an error code.
	*
	* bits are first added to a local register.
	* Local register is size_t, hence 64-bits on 64-bits systems, or 32-bits on 32-bits systems.
	* Writing data into memory is an explicit operation, performed by the flushBits function.
	* Hence keep track how many bits are potentially stored into local register to avoid register overflow.
	* After a flushBits, a maximum of 7 bits might still be stored into local register.
	*
	* Avoid storing elements of more than 24 bits if you want compatibility with 32-bits bitstream readers.
	*
	* Last operation is to close the bitStream.
	* The function returns the final size of CStream in bytes.
	* If data couldn't fit into `dstBuffer`, it will return a 0 ( == not storable)
	*/


	/-*******************************************
	* bitStream decoding API (read backward)
	**********************************************/
	typedef struct {
	size_t bitContainer;
	unsigned bitsConsumed;
	const char* ptr;
	const char* start;
	const char* limitPtr;
	} BIT_DStream_t;

	typedef enum { BIT_DStream_unfinished = 0,
	BIT_DStream_endOfBuffer = 1,
	BIT_DStream_completed = 2,
	BIT_DStream_overflow = 3 } BIT_DStream_status; /* result of BIT_reloadDStream() */
	/* 1,2,4,8 would be better for bitmap combinations, but slows down performance a bit ... :( */

	MEM_STATIC size_t BIT_initDStream(BIT_DStream_t* bitD, const void* srcBuffer, size_t srcSize);
	MEM_STATIC size_t BIT_readBits(BIT_DStream_t* bitD, unsigned nbBits);
	MEM_STATIC BIT_DStream_status BIT_reloadDStream(BIT_DStream_t* bitD);
	MEM_STATIC unsigned BIT_endOfDStream(const BIT_DStream_t* bitD);


	/* Start by invoking BIT_initDStream().
	* A chunk of the bitStream is then stored into a local register.
	* Local register size is 64-bits on 64-bits systems, 32-bits on 32-bits systems (size_t).
	* You can then retrieve bitFields stored into the local register, in reverse order.
	* Local register is explicitly reloaded from memory by the BIT_reloadDStream() method.
	* A reload guarantee a minimum of ((8*sizeof(bitD->bitContainer))-7) bits when its result is BIT_DStream_unfinished.
	* Otherwise, it can be less than that, so proceed accordingly.
	* Checking if DStream has reached its end can be performed with BIT_endOfDStream().
	*/


	/-***************************************
	* unsafe API
	******************************************/
	MEM_STATIC void BIT_addBitsFast(BIT_CStream_t* bitC, size_t value, unsigned nbBits);
	/* faster, but works only if value is "clean", meaning all high bits above nbBits are 0 */

	MEM_STATIC void BIT_flushBitsFast(BIT_CStream_t* bitC);
	/* unsafe version; does not check buffer overflow */

	MEM_STATIC size_t BIT_readBitsFast(BIT_DStream_t* bitD, unsigned nbBits);
	/* faster, but works only if nbBits >= 1 */



	/-*************************************************************
	* Internal functions
	****************************************************************/
	MEM_STATIC unsigned BIT_highbit32 (U32 val)
	{
	assert(val != 0);
	{
	# if defined(_MSC_VER) /* Visual */
	unsigned long r=0;
	return _BitScanReverse ( &r, val ) ? (unsigned)r : 0;
	# elif defined(__GNUC__) && (__GNUC__ >= 3) /* Use GCC Intrinsic */
	return __builtin_clz (val) ^ 31;
	# elif defined(__ICCARM__) /* IAR Intrinsic */
	return 31 - __CLZ(val);
	# else /* Software version */
	static const unsigned DeBruijnClz[32] = { 0, 9, 1, 10, 13, 21, 2, 29,
	11, 14, 16, 18, 22, 25, 3, 30,
	8, 12, 20, 28, 15, 17, 24, 7,
	19, 27, 23, 6, 26, 5, 4, 31 };
	U32 v = val;
	v \|= v >> 1;
	v \|= v >> 2;
	v \|= v >> 4;
	v \|= v >> 8;
	v \|= v >> 16;
	return DeBruijnClz[ (U32) (v * 0x07C4ACDDU) >> 27];
	# endif
	}
	}

	/===== Local Constants =====/
	static const unsigned BIT_mask[] = {
	0, 1, 3, 7, 0xF, 0x1F,
	0x3F, 0x7F, 0xFF, 0x1FF, 0x3FF, 0x7FF,
	0xFFF, 0x1FFF, 0x3FFF, 0x7FFF, 0xFFFF, 0x1FFFF,
	0x3FFFF, 0x7FFFF, 0xFFFFF, 0x1FFFFF, 0x3FFFFF, 0x7FFFFF,
	0xFFFFFF, 0x1FFFFFF, 0x3FFFFFF, 0x7FFFFFF, 0xFFFFFFF, 0x1FFFFFFF,
	0x3FFFFFFF, 0x7FFFFFFF}; /* up to 31 bits */
	#define BIT_MASK_SIZE (sizeof(BIT_mask) / sizeof(BIT_mask[0]))

	/-*************************************************************
	* bitStream encoding
	****************************************************************/
	/*! BIT_initCStream() :
	* `dstCapacity` must be > sizeof(size_t)
	* @return : 0 if success,
	* otherwise an error code (can be tested using ERR_isError()) */
	MEM_STATIC size_t BIT_initCStream(BIT_CStream_t* bitC,
	void* startPtr, size_t dstCapacity)
	{
	bitC->bitContainer = 0;
	bitC->bitPos = 0;
	bitC->startPtr = (char*)startPtr;
	bitC->ptr = bitC->startPtr;
	bitC->endPtr = bitC->startPtr + dstCapacity - sizeof(bitC->bitContainer);
	if (dstCapacity <= sizeof(bitC->bitContainer)) return ERROR(dstSize_tooSmall);
	return 0;
	}

	/*! BIT_addBits() :
	* can add up to 31 bits into `bitC`.
	* Note : does not check for register overflow ! */
	MEM_STATIC void BIT_addBits(BIT_CStream_t* bitC,
	size_t value, unsigned nbBits)
	{
	MEM_STATIC_ASSERT(BIT_MASK_SIZE == 32);
	assert(nbBits < BIT_MASK_SIZE);
	assert(nbBits + bitC->bitPos < sizeof(bitC->bitContainer) * 8);
	bitC->bitContainer \|= (value & BIT_mask[nbBits]) << bitC->bitPos;
	bitC->bitPos += nbBits;
	}

	/*! BIT_addBitsFast() :
	* works only if `value` is _clean_,
	* meaning all high bits above nbBits are 0 */
	MEM_STATIC void BIT_addBitsFast(BIT_CStream_t* bitC,
	size_t value, unsigned nbBits)
	{
	assert((value>>nbBits) == 0);
	assert(nbBits + bitC->bitPos < sizeof(bitC->bitContainer) * 8);
	bitC->bitContainer \|= value << bitC->bitPos;
	bitC->bitPos += nbBits;
	}

	/*! BIT_flushBitsFast() :
	* assumption : bitContainer has not overflowed
	* unsafe version; does not check buffer overflow */
	MEM_STATIC void BIT_flushBitsFast(BIT_CStream_t* bitC)
	{
	size_t const nbBytes = bitC->bitPos >> 3;
	assert(bitC->bitPos < sizeof(bitC->bitContainer) * 8);
	assert(bitC->ptr <= bitC->endPtr);
	MEM_writeLEST(bitC->ptr, bitC->bitContainer);
	bitC->ptr += nbBytes;
	bitC->bitPos &= 7;
	bitC->bitContainer >>= nbBytes*8;
	}

	/*! BIT_flushBits() :
	* assumption : bitContainer has not overflowed
	* safe version; check for buffer overflow, and prevents it.
	* note : does not signal buffer overflow.
	* overflow will be revealed later on using BIT_closeCStream() */
	MEM_STATIC void BIT_flushBits(BIT_CStream_t* bitC)
	{
	size_t const nbBytes = bitC->bitPos >> 3;
	assert(bitC->bitPos < sizeof(bitC->bitContainer) * 8);
	assert(bitC->ptr <= bitC->endPtr);
	MEM_writeLEST(bitC->ptr, bitC->bitContainer);
	bitC->ptr += nbBytes;
	if (bitC->ptr > bitC->endPtr) bitC->ptr = bitC->endPtr;
	bitC->bitPos &= 7;
	bitC->bitContainer >>= nbBytes*8;
	}

	/*! BIT_closeCStream() :
	* @return : size of CStream, in bytes,
	* or 0 if it could not fit into dstBuffer */
	MEM_STATIC size_t BIT_closeCStream(BIT_CStream_t* bitC)
	{
	BIT_addBitsFast(bitC, 1, 1); /* endMark */
	BIT_flushBits(bitC);
	if (bitC->ptr >= bitC->endPtr) return 0; /* overflow detected */
	return (bitC->ptr - bitC->startPtr) + (bitC->bitPos > 0);
	}


	/-*******************************************************
	* bitStream decoding
	**********************************************************/
	/*! BIT_initDStream() :
	* Initialize a BIT_DStream_t.
	* `bitD` : a pointer to an already allocated BIT_DStream_t structure.
	* `srcSize` must be the exact size of the bitStream, in bytes.
	* @return : size of stream (== srcSize), or an errorCode if a problem is detected
	*/
	MEM_STATIC size_t BIT_initDStream(BIT_DStream_t* bitD, const void* srcBuffer, size_t srcSize)
	{
	if (srcSize < 1) { memset(bitD, 0, sizeof(*bitD)); return ERROR(srcSize_wrong); }

	bitD->start = (const char*)srcBuffer;
	bitD->limitPtr = bitD->start + sizeof(bitD->bitContainer);

	if (srcSize >= sizeof(bitD->bitContainer)) { /* normal case */
	bitD->ptr = (const char*)srcBuffer + srcSize - sizeof(bitD->bitContainer);
	bitD->bitContainer = MEM_readLEST(bitD->ptr);
	{ BYTE const lastByte = ((const BYTE*)srcBuffer)[srcSize-1];
	bitD->bitsConsumed = lastByte ? 8 - BIT_highbit32(lastByte) : 0; /* ensures bitsConsumed is always set */
	if (lastByte == 0) return ERROR(GENERIC); /* endMark not present */ }
	} else {
	bitD->ptr = bitD->start;
	bitD->bitContainer = (const BYTE)(bitD->start);
	switch(srcSize)
	{
	case 7: bitD->bitContainer += (size_t)(((const BYTE)(srcBuffer))[6]) << (sizeof(bitD->bitContainer)8 - 16);
	/* fall-through */

	case 6: bitD->bitContainer += (size_t)(((const BYTE)(srcBuffer))[5]) << (sizeof(bitD->bitContainer)8 - 24);
	/* fall-through */

	case 5: bitD->bitContainer += (size_t)(((const BYTE)(srcBuffer))[4]) << (sizeof(bitD->bitContainer)8 - 32);
	/* fall-through */

	case 4: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[3]) << 24;
	/* fall-through */

	case 3: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[2]) << 16;
	/* fall-through */

	case 2: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[1]) << 8;
	/* fall-through */

	default: break;
	}
	{ BYTE const lastByte = ((const BYTE*)srcBuffer)[srcSize-1];
	bitD->bitsConsumed = lastByte ? 8 - BIT_highbit32(lastByte) : 0;
	if (lastByte == 0) return ERROR(corruption_detected); /* endMark not present */
	}
	bitD->bitsConsumed += (U32)(sizeof(bitD->bitContainer) - srcSize)*8;
	}

	return srcSize;
	}

	MEM_STATIC size_t BIT_getUpperBits(size_t bitContainer, U32 const start)
	{
	return bitContainer >> start;
	}

	MEM_STATIC size_t BIT_getMiddleBits(size_t bitContainer, U32 const start, U32 const nbBits)
	{
	U32 const regMask = sizeof(bitContainer)*8 - 1;
	/* if start > regMask, bitstream is corrupted, and result is undefined */
	assert(nbBits < BIT_MASK_SIZE);
	return (bitContainer >> (start & regMask)) & BIT_mask[nbBits];
	}

	MEM_STATIC size_t BIT_getLowerBits(size_t bitContainer, U32 const nbBits)
	{
	assert(nbBits < BIT_MASK_SIZE);
	return bitContainer & BIT_mask[nbBits];
	}

	/*! BIT_lookBits() :
	* Provides next n bits from local register.
	* local register is not modified.
	* On 32-bits, maxNbBits==24.
	* On 64-bits, maxNbBits==56.
	* @return : value extracted */
	MEM_STATIC size_t BIT_lookBits(const BIT_DStream_t* bitD, U32 nbBits)
	{
	/* arbitrate between double-shift and shift+mask */
	#if 1
	/* if bitD->bitsConsumed + nbBits > sizeof(bitD->bitContainer)*8,
	* bitstream is likely corrupted, and result is undefined */
	return BIT_getMiddleBits(bitD->bitContainer, (sizeof(bitD->bitContainer)*8) - bitD->bitsConsumed - nbBits, nbBits);
	#else
	/* this code path is slower on my os-x laptop */
	U32 const regMask = sizeof(bitD->bitContainer)*8 - 1;
	return ((bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> 1) >> ((regMask-nbBits) & regMask);
	#endif
	}

	/*! BIT_lookBitsFast() :
	* unsafe version; only works if nbBits >= 1 */
	MEM_STATIC size_t BIT_lookBitsFast(const BIT_DStream_t* bitD, U32 nbBits)
	{
	U32 const regMask = sizeof(bitD->bitContainer)*8 - 1;
	assert(nbBits >= 1);
	return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask);
	}

	MEM_STATIC void BIT_skipBits(BIT_DStream_t* bitD, U32 nbBits)
	{
	bitD->bitsConsumed += nbBits;
	}

	/*! BIT_readBits() :
	* Read (consume) next n bits from local register and update.
	* Pay attention to not read more than nbBits contained into local register.
	* @return : extracted value. */
	MEM_STATIC size_t BIT_readBits(BIT_DStream_t* bitD, unsigned nbBits)
	{
	size_t const value = BIT_lookBits(bitD, nbBits);
	BIT_skipBits(bitD, nbBits);
	return value;
	}

	/*! BIT_readBitsFast() :
	* unsafe version; only works only if nbBits >= 1 */
	MEM_STATIC size_t BIT_readBitsFast(BIT_DStream_t* bitD, unsigned nbBits)
	{
	size_t const value = BIT_lookBitsFast(bitD, nbBits);
	assert(nbBits >= 1);
	BIT_skipBits(bitD, nbBits);
	return value;
	}

	/*! BIT_reloadDStreamFast() :
	* Similar to BIT_reloadDStream(), but with two differences:
	* 1. bitsConsumed <= sizeof(bitD->bitContainer)*8 must hold!
	* 2. Returns BIT_DStream_overflow when bitD->ptr < bitD->limitPtr, at this
	* point you must use BIT_reloadDStream() to reload.
	*/
	MEM_STATIC BIT_DStream_status BIT_reloadDStreamFast(BIT_DStream_t* bitD)
	{
	if (UNLIKELY(bitD->ptr < bitD->limitPtr))
	return BIT_DStream_overflow;
	assert(bitD->bitsConsumed <= sizeof(bitD->bitContainer)*8);
	bitD->ptr -= bitD->bitsConsumed >> 3;
	bitD->bitsConsumed &= 7;
	bitD->bitContainer = MEM_readLEST(bitD->ptr);
	return BIT_DStream_unfinished;
	}

	/*! BIT_reloadDStream() :
	* Refill `bitD` from buffer previously set in BIT_initDStream() .
	* This function is safe, it guarantees it will not read beyond src buffer.
	* @return : status of `BIT_DStream_t` internal register.
	* when status == BIT_DStream_unfinished, internal register is filled with at least 25 or 57 bits */
	MEM_STATIC BIT_DStream_status BIT_reloadDStream(BIT_DStream_t* bitD)
	{
	if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)8)) / overflow detected, like end of stream */
	return BIT_DStream_overflow;

	if (bitD->ptr >= bitD->limitPtr) {
	return BIT_reloadDStreamFast(bitD);
	}
	if (bitD->ptr == bitD->start) {
	if (bitD->bitsConsumed < sizeof(bitD->bitContainer)*8) return BIT_DStream_endOfBuffer;
	return BIT_DStream_completed;
	}
	/* start < ptr < limitPtr */
	{ U32 nbBytes = bitD->bitsConsumed >> 3;
	BIT_DStream_status result = BIT_DStream_unfinished;
	if (bitD->ptr - nbBytes < bitD->start) {
	nbBytes = (U32)(bitD->ptr - bitD->start); /* ptr > start */
	result = BIT_DStream_endOfBuffer;
	}
	bitD->ptr -= nbBytes;
	bitD->bitsConsumed -= nbBytes*8;
	bitD->bitContainer = MEM_readLEST(bitD->ptr); /* reminder : srcSize > sizeof(bitD->bitContainer), otherwise bitD->ptr == bitD->start */
	return result;
	}
	}

	/*! BIT_endOfDStream() :
	* @return : 1 if DStream has _exactly_ reached its end (all bits consumed).
	*/
	MEM_STATIC unsigned BIT_endOfDStream(const BIT_DStream_t* DStream)
	{
	return ((DStream->ptr == DStream->start) && (DStream->bitsConsumed == sizeof(DStream->bitContainer)*8));
	}

	#if defined (__cplusplus)
	}
	#endif

	#endif /* BITSTREAM_H_MODULE */
	/** ended inlining bitstream.h **/


	/* *****************************************
	* Static allocation
	*******************************************/
	/* FSE buffer bounds */
	#define FSE_NCOUNTBOUND 512
	#define FSE_BLOCKBOUND(size) (size + (size>>7) + 4 /* fse states / + sizeof(size_t) / bitContainer */)
	#define FSE_COMPRESSBOUND(size) (FSE_NCOUNTBOUND + FSE_BLOCKBOUND(size)) /* Macro version, useful for static allocation */

	/* It is possible to statically allocate FSE CTable/DTable as a table of FSE_CTable/FSE_DTable using below macros */
	#define FSE_CTABLE_SIZE_U32(maxTableLog, maxSymbolValue) (1 + (1<<(maxTableLog-1)) + ((maxSymbolValue+1)*2))
	#define FSE_DTABLE_SIZE_U32(maxTableLog) (1 + (1<<maxTableLog))

	/* or use the size to malloc() space directly. Pay attention to alignment restrictions though */
	#define FSE_CTABLE_SIZE(maxTableLog, maxSymbolValue) (FSE_CTABLE_SIZE_U32(maxTableLog, maxSymbolValue) * sizeof(FSE_CTable))
	#define FSE_DTABLE_SIZE(maxTableLog) (FSE_DTABLE_SIZE_U32(maxTableLog) * sizeof(FSE_DTable))


	/* *****************************************
	* FSE advanced API
	***************************************** */

	unsigned FSE_optimalTableLog_internal(unsigned maxTableLog, size_t srcSize, unsigned maxSymbolValue, unsigned minus);
	/*< same as FSE_optimalTableLog(), which used `minus==2` /

	/* FSE_compress_wksp() :
	* Same as FSE_compress2(), but using an externally allocated scratch buffer (`workSpace`).
	* FSE_WKSP_SIZE_U32() provides the minimum size required for `workSpace` as a table of FSE_CTable.
	*/
	#define FSE_WKSP_SIZE_U32(maxTableLog, maxSymbolValue) ( FSE_CTABLE_SIZE_U32(maxTableLog, maxSymbolValue) + ((maxTableLog > 12) ? (1 << (maxTableLog - 2)) : 1024) )
	size_t FSE_compress_wksp (void* dst, size_t dstSize, const void* src, size_t srcSize, unsigned maxSymbolValue, unsigned tableLog, void* workSpace, size_t wkspSize);

	size_t FSE_buildCTable_raw (FSE_CTable* ct, unsigned nbBits);
	/*< build a fake FSE_CTable, designed for a flat distribution, where each symbol uses nbBits /

	size_t FSE_buildCTable_rle (FSE_CTable* ct, unsigned char symbolValue);
	/*< build a fake FSE_CTable, designed to compress always the same symbolValue /

	/* FSE_buildCTable_wksp() :
	* Same as FSE_buildCTable(), but using an externally allocated scratch buffer (`workSpace`).
	* `wkspSize` must be >= `(1<<tableLog)`.
	*/
	size_t FSE_buildCTable_wksp(FSE_CTable* ct, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog, void* workSpace, size_t wkspSize);

	size_t FSE_buildDTable_raw (FSE_DTable* dt, unsigned nbBits);
	/*< build a fake FSE_DTable, designed to read a flat distribution where each symbol uses nbBits /

	size_t FSE_buildDTable_rle (FSE_DTable* dt, unsigned char symbolValue);
	/*< build a fake FSE_DTable, designed to always generate the same symbolValue /

	size_t FSE_decompress_wksp(void* dst, size_t dstCapacity, const void* cSrc, size_t cSrcSize, FSE_DTable* workSpace, unsigned maxLog);
	/*< same as FSE_decompress(), using an externally allocated `workSpace` produced with `FSE_DTABLE_SIZE_U32(maxLog)` /

	typedef enum {
	FSE_repeat_none, /*< Cannot use the previous table /
	FSE_repeat_check, /*< Can use the previous table but it must be checked /
	FSE_repeat_valid /*< Can use the previous table and it is assumed to be valid /
	} FSE_repeat;

	/* *****************************************
	* FSE symbol compression API
	*******************************************/
	/*!
	This API consists of small unitary functions, which highly benefit from being inlined.
	Hence their body are included in next section.
	*/
	typedef struct {
	ptrdiff_t value;
	const void* stateTable;
	const void* symbolTT;
	unsigned stateLog;
	} FSE_CState_t;

	static void FSE_initCState(FSE_CState_t* CStatePtr, const FSE_CTable* ct);

	static void FSE_encodeSymbol(BIT_CStream_t* bitC, FSE_CState_t* CStatePtr, unsigned symbol);

	static void FSE_flushCState(BIT_CStream_t* bitC, const FSE_CState_t* CStatePtr);

	/**<
	These functions are inner components of FSE_compress_usingCTable().
	They allow the creation of custom streams, mixing multiple tables and bit sources.

	A key property to keep in mind is that encoding and decoding are done in reverse direction.
	So the first symbol you will encode is the last you will decode, like a LIFO stack.

	You will need a few variables to track your CStream. They are :

	FSE_CTable ct; // Provided by FSE_buildCTable()
	BIT_CStream_t bitStream; // bitStream tracking structure
	FSE_CState_t state; // State tracking structure (can have several)


	The first thing to do is to init bitStream and state.
	size_t errorCode = BIT_initCStream(&bitStream, dstBuffer, maxDstSize);
	FSE_initCState(&state, ct);

	Note that BIT_initCStream() can produce an error code, so its result should be tested, using FSE_isError();
	You can then encode your input data, byte after byte.
	FSE_encodeSymbol() outputs a maximum of 'tableLog' bits at a time.
	Remember decoding will be done in reverse direction.
	FSE_encodeByte(&bitStream, &state, symbol);

	At any time, you can also add any bit sequence.
	Note : maximum allowed nbBits is 25, for compatibility with 32-bits decoders
	BIT_addBits(&bitStream, bitField, nbBits);

	The above methods don't commit data to memory, they just store it into local register, for speed.
	Local register size is 64-bits on 64-bits systems, 32-bits on 32-bits systems (size_t).
	Writing data to memory is a manual operation, performed by the flushBits function.
	BIT_flushBits(&bitStream);

	Your last FSE encoding operation shall be to flush your last state value(s).
	FSE_flushState(&bitStream, &state);

	Finally, you must close the bitStream.
	The function returns the size of CStream in bytes.
	If data couldn't fit into dstBuffer, it will return a 0 ( == not compressible)
	If there is an error, it returns an errorCode (which can be tested using FSE_isError()).
	size_t size = BIT_closeCStream(&bitStream);
	*/


	/* *****************************************
	* FSE symbol decompression API
	*******************************************/
	typedef struct {
	size_t state;
	const void* table; /* precise table may vary, depending on U16 */
	} FSE_DState_t;


	static void FSE_initDState(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD, const FSE_DTable* dt);

	static unsigned char FSE_decodeSymbol(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD);

	static unsigned FSE_endOfDState(const FSE_DState_t* DStatePtr);

	/**<
	Let's now decompose FSE_decompress_usingDTable() into its unitary components.
	You will decode FSE-encoded symbols from the bitStream,
	and also any other bitFields you put in, in reverse order.

	You will need a few variables to track your bitStream. They are :

	BIT_DStream_t DStream; // Stream context
	FSE_DState_t DState; // State context. Multiple ones are possible
	FSE_DTable* DTablePtr; // Decoding table, provided by FSE_buildDTable()

	The first thing to do is to init the bitStream.
	errorCode = BIT_initDStream(&DStream, srcBuffer, srcSize);

	You should then retrieve your initial state(s)
	(in reverse flushing order if you have several ones) :
	errorCode = FSE_initDState(&DState, &DStream, DTablePtr);

	You can then decode your data, symbol after symbol.
	For information the maximum number of bits read by FSE_decodeSymbol() is 'tableLog'.
	Keep in mind that symbols are decoded in reverse order, like a LIFO stack (last in, first out).
	unsigned char symbol = FSE_decodeSymbol(&DState, &DStream);

	You can retrieve any bitfield you eventually stored into the bitStream (in reverse order)
	Note : maximum allowed nbBits is 25, for 32-bits compatibility
	size_t bitField = BIT_readBits(&DStream, nbBits);

	All above operations only read from local register (which size depends on size_t).
	Refueling the register from memory is manually performed by the reload method.
	endSignal = FSE_reloadDStream(&DStream);

	BIT_reloadDStream() result tells if there is still some more data to read from DStream.
	BIT_DStream_unfinished : there is still some data left into the DStream.
	BIT_DStream_endOfBuffer : Dstream reached end of buffer. Its container may no longer be completely filled.
	BIT_DStream_completed : Dstream reached its exact end, corresponding in general to decompression completed.
	BIT_DStream_tooFar : Dstream went too far. Decompression result is corrupted.

	When reaching end of buffer (BIT_DStream_endOfBuffer), progress slowly, notably if you decode multiple symbols per loop,
	to properly detect the exact end of stream.
	After each decoded symbol, check if DStream is fully consumed using this simple test :
	BIT_reloadDStream(&DStream) >= BIT_DStream_completed

	When it's done, verify decompression is fully completed, by checking both DStream and the relevant states.
	Checking if DStream has reached its end is performed by :
	BIT_endOfDStream(&DStream);
	Check also the states. There might be some symbols left there, if some high probability ones (>50%) are possible.
	FSE_endOfDState(&DState);
	*/


	/* *****************************************
	* FSE unsafe API
	*******************************************/
	static unsigned char FSE_decodeSymbolFast(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD);
	/* faster, but works only if nbBits is always >= 1 (otherwise, result will be corrupted) */


	/* *****************************************
	* Implementation of inlined functions
	*******************************************/
	typedef struct {
	int deltaFindState;
	U32 deltaNbBits;
	} FSE_symbolCompressionTransform; /* total 8 bytes */

	MEM_STATIC void FSE_initCState(FSE_CState_t* statePtr, const FSE_CTable* ct)
	{
	const void* ptr = ct;
	const U16* u16ptr = (const U16*) ptr;
	const U32 tableLog = MEM_read16(ptr);
	statePtr->value = (ptrdiff_t)1<<tableLog;
	statePtr->stateTable = u16ptr+2;
	statePtr->symbolTT = ct + 1 + (tableLog ? (1<<(tableLog-1)) : 1);
	statePtr->stateLog = tableLog;
	}


	/*! FSE_initCState2() :
	* Same as FSE_initCState(), but the first symbol to include (which will be the last to be read)
	* uses the smallest state value possible, saving the cost of this symbol */
	MEM_STATIC void FSE_initCState2(FSE_CState_t* statePtr, const FSE_CTable* ct, U32 symbol)
	{
	FSE_initCState(statePtr, ct);
	{ const FSE_symbolCompressionTransform symbolTT = ((const FSE_symbolCompressionTransform*)(statePtr->symbolTT))[symbol];
	const U16* stateTable = (const U16*)(statePtr->stateTable);
	U32 nbBitsOut = (U32)((symbolTT.deltaNbBits + (1<<15)) >> 16);
	statePtr->value = (nbBitsOut << 16) - symbolTT.deltaNbBits;
	statePtr->value = stateTable[(statePtr->value >> nbBitsOut) + symbolTT.deltaFindState];
	}
	}

	MEM_STATIC void FSE_encodeSymbol(BIT_CStream_t* bitC, FSE_CState_t* statePtr, unsigned symbol)
	{
	FSE_symbolCompressionTransform const symbolTT = ((const FSE_symbolCompressionTransform*)(statePtr->symbolTT))[symbol];
	const U16* const stateTable = (const U16*)(statePtr->stateTable);
	U32 const nbBitsOut = (U32)((statePtr->value + symbolTT.deltaNbBits) >> 16);
	BIT_addBits(bitC, statePtr->value, nbBitsOut);
	statePtr->value = stateTable[ (statePtr->value >> nbBitsOut) + symbolTT.deltaFindState];
	}

	MEM_STATIC void FSE_flushCState(BIT_CStream_t* bitC, const FSE_CState_t* statePtr)
	{
	BIT_addBits(bitC, statePtr->value, statePtr->stateLog);
	BIT_flushBits(bitC);
	}


	/* FSE_getMaxNbBits() :
	* Approximate maximum cost of a symbol, in bits.
	* Fractional get rounded up (i.e : a symbol with a normalized frequency of 3 gives the same result as a frequency of 2)
	* note 1 : assume symbolValue is valid (<= maxSymbolValue)
	* note 2 : if freq[symbolValue]==0, @return a fake cost of tableLog+1 bits */
	MEM_STATIC U32 FSE_getMaxNbBits(const void* symbolTTPtr, U32 symbolValue)
	{
	const FSE_symbolCompressionTransform* symbolTT = (const FSE_symbolCompressionTransform*) symbolTTPtr;
	return (symbolTT[symbolValue].deltaNbBits + ((1<<16)-1)) >> 16;
	}

	/* FSE_bitCost() :
	* Approximate symbol cost, as fractional value, using fixed-point format (accuracyLog fractional bits)
	* note 1 : assume symbolValue is valid (<= maxSymbolValue)
	* note 2 : if freq[symbolValue]==0, @return a fake cost of tableLog+1 bits */
	MEM_STATIC U32 FSE_bitCost(const void* symbolTTPtr, U32 tableLog, U32 symbolValue, U32 accuracyLog)
	{
	const FSE_symbolCompressionTransform* symbolTT = (const FSE_symbolCompressionTransform*) symbolTTPtr;
	U32 const minNbBits = symbolTT[symbolValue].deltaNbBits >> 16;
	U32 const threshold = (minNbBits+1) << 16;
	assert(tableLog < 16);
	assert(accuracyLog < 31-tableLog); /* ensure enough room for renormalization double shift */
	{ U32 const tableSize = 1 << tableLog;
	U32 const deltaFromThreshold = threshold - (symbolTT[symbolValue].deltaNbBits + tableSize);
	U32 const normalizedDeltaFromThreshold = (deltaFromThreshold << accuracyLog) >> tableLog; /* linear interpolation (very approximate) */
	U32 const bitMultiplier = 1 << accuracyLog;
	assert(symbolTT[symbolValue].deltaNbBits + tableSize <= threshold);
	assert(normalizedDeltaFromThreshold <= bitMultiplier);
	return (minNbBits+1)*bitMultiplier - normalizedDeltaFromThreshold;
	}
	}


	/* ====== Decompression ====== */

	typedef struct {
	U16 tableLog;
	U16 fastMode;
	} FSE_DTableHeader; /* sizeof U32 */

	typedef struct
	{
	unsigned short newState;
	unsigned char symbol;
	unsigned char nbBits;
	} FSE_decode_t; /* size == U32 */

	MEM_STATIC void FSE_initDState(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD, const FSE_DTable* dt)
	{
	const void* ptr = dt;
	const FSE_DTableHeader* const DTableH = (const FSE_DTableHeader*)ptr;
	DStatePtr->state = BIT_readBits(bitD, DTableH->tableLog);
	BIT_reloadDStream(bitD);
	DStatePtr->table = dt + 1;
	}

	MEM_STATIC BYTE FSE_peekSymbol(const FSE_DState_t* DStatePtr)
	{
	FSE_decode_t const DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state];
	return DInfo.symbol;
	}

	MEM_STATIC void FSE_updateState(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD)
	{
	FSE_decode_t const DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state];
	U32 const nbBits = DInfo.nbBits;
	size_t const lowBits = BIT_readBits(bitD, nbBits);
	DStatePtr->state = DInfo.newState + lowBits;
	}

	MEM_STATIC BYTE FSE_decodeSymbol(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD)
	{
	FSE_decode_t const DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state];
	U32 const nbBits = DInfo.nbBits;
	BYTE const symbol = DInfo.symbol;
	size_t const lowBits = BIT_readBits(bitD, nbBits);

	DStatePtr->state = DInfo.newState + lowBits;
	return symbol;
	}

	/*! FSE_decodeSymbolFast() :
	unsafe, only works if no symbol has a probability > 50% */
	MEM_STATIC BYTE FSE_decodeSymbolFast(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD)
	{
	FSE_decode_t const DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state];
	U32 const nbBits = DInfo.nbBits;
	BYTE const symbol = DInfo.symbol;
	size_t const lowBits = BIT_readBitsFast(bitD, nbBits);

	DStatePtr->state = DInfo.newState + lowBits;
	return symbol;
	}

	MEM_STATIC unsigned FSE_endOfDState(const FSE_DState_t* DStatePtr)
	{
	return DStatePtr->state == 0;
	}



	#ifndef FSE_COMMONDEFS_ONLY

	/* **************************************************************
	* Tuning parameters
	****************************************************************/
	/*!MEMORY_USAGE :
	* Memory usage formula : N->2^N Bytes (examples : 10 -> 1KB; 12 -> 4KB ; 16 -> 64KB; 20 -> 1MB; etc.)
	* Increasing memory usage improves compression ratio
	* Reduced memory usage can improve speed, due to cache effect
	* Recommended max value is 14, for 16KB, which nicely fits into Intel x86 L1 cache */
	#ifndef FSE_MAX_MEMORY_USAGE
	# define FSE_MAX_MEMORY_USAGE 14
	#endif
	#ifndef FSE_DEFAULT_MEMORY_USAGE
	# define FSE_DEFAULT_MEMORY_USAGE 13
	#endif

	/*!FSE_MAX_SYMBOL_VALUE :
	* Maximum symbol value authorized.
	* Required for proper stack allocation */
	#ifndef FSE_MAX_SYMBOL_VALUE
	# define FSE_MAX_SYMBOL_VALUE 255
	#endif

	/* **************************************************************
	* template functions type & suffix
	****************************************************************/
	#define FSE_FUNCTION_TYPE BYTE
	#define FSE_FUNCTION_EXTENSION
	#define FSE_DECODE_TYPE FSE_decode_t


	#endif /* !FSE_COMMONDEFS_ONLY */


	/* ***************************************************************
	* Constants
	*****************************************************************/
	#define FSE_MAX_TABLELOG (FSE_MAX_MEMORY_USAGE-2)
	#define FSE_MAX_TABLESIZE (1U<<FSE_MAX_TABLELOG)
	#define FSE_MAXTABLESIZE_MASK (FSE_MAX_TABLESIZE-1)
	#define FSE_DEFAULT_TABLELOG (FSE_DEFAULT_MEMORY_USAGE-2)
	#define FSE_MIN_TABLELOG 5

	#define FSE_TABLELOG_ABSOLUTE_MAX 15
	#if FSE_MAX_TABLELOG > FSE_TABLELOG_ABSOLUTE_MAX
	# error "FSE_MAX_TABLELOG > FSE_TABLELOG_ABSOLUTE_MAX is not supported"
	#endif

	#define FSE_TABLESTEP(tableSize) ((tableSize>>1) + (tableSize>>3) + 3)


	#endif /* FSE_STATIC_LINKING_ONLY */


	#if defined (__cplusplus)
	}
	#endif
	/** ended inlining fse.h **/
	#define HUF_STATIC_LINKING_ONLY /* HUF_TABLELOG_ABSOLUTEMAX */
	/** start inlining huf.h **/
	/* ******************************************************************
	* huff0 huffman codec,
	* part of Finite State Entropy library
	* Copyright (c) 2013-2020, Yann Collet, Facebook, Inc.
	*
	* You can contact the author at :
	* - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
	*
	* This source code is licensed under both the BSD-style license (found in the
	* LICENSE file in the root directory of this source tree) and the GPLv2 (found
	* in the COPYING file in the root directory of this source tree).
	* You may select, at your option, one of the above-listed licenses.
	****************************************************************** */

	#if defined (__cplusplus)
	extern "C" {
	#endif

	#ifndef HUF_H_298734234
	#define HUF_H_298734234

	/* * Dependencies * */
	#include <stddef.h> /* size_t */


	/* * library symbols visibility * */
	/* Note : when linking with -fvisibility=hidden on gcc, or by default on Visual,
	* HUF symbols remain "private" (internal symbols for library only).
	* Set macro FSE_DLL_EXPORT to 1 if you want HUF symbols visible on DLL interface */
	#if defined(FSE_DLL_EXPORT) && (FSE_DLL_EXPORT==1) && defined(__GNUC__) && (__GNUC__ >= 4)
	# define HUF_PUBLIC_API __attribute__ ((visibility ("default")))
	#elif defined(FSE_DLL_EXPORT) && (FSE_DLL_EXPORT==1) /* Visual expected */
	# define HUF_PUBLIC_API __declspec(dllexport)
	#elif defined(FSE_DLL_IMPORT) && (FSE_DLL_IMPORT==1)
	# define HUF_PUBLIC_API __declspec(dllimport) /* not required, just to generate faster code (saves a function pointer load from IAT and an indirect jump) */
	#else
	# define HUF_PUBLIC_API
	#endif


	/* ========================== */
	/* * simple functions * */
	/* ========================== */

	/** HUF_compress() :
	* Compress content from buffer 'src', of size 'srcSize', into buffer 'dst'.
	* 'dst' buffer must be already allocated.
	* Compression runs faster if `dstCapacity` >= HUF_compressBound(srcSize).
	* `srcSize` must be <= `HUF_BLOCKSIZE_MAX` == 128 KB.
	* @return : size of compressed data (<= `dstCapacity`).
	* Special values : if return == 0, srcData is not compressible => Nothing is stored within dst !!!
	* if HUF_isError(return), compression failed (more details using HUF_getErrorName())
	*/
	HUF_PUBLIC_API size_t HUF_compress(void* dst, size_t dstCapacity,
	const void* src, size_t srcSize);

	/** HUF_decompress() :
	* Decompress HUF data from buffer 'cSrc', of size 'cSrcSize',
	* into already allocated buffer 'dst', of minimum size 'dstSize'.
	* `originalSize` : must be the *exact* size of original (uncompressed) data.
	* Note : in contrast with FSE, HUF_decompress can regenerate
	* RLE (cSrcSize==1) and uncompressed (cSrcSize==dstSize) data,
	* because it knows size to regenerate (originalSize).
	* @return : size of regenerated data (== originalSize),
	* or an error code, which can be tested using HUF_isError()
	*/
	HUF_PUBLIC_API size_t HUF_decompress(void* dst, size_t originalSize,
	const void* cSrc, size_t cSrcSize);


	/* * Tool functions * */
	#define HUF_BLOCKSIZE_MAX (128 * 1024) /*< maximum input size for a single block compressed with HUF_compress /
	HUF_PUBLIC_API size_t HUF_compressBound(size_t size); /*< maximum compressed size (worst case) /

	/* Error Management */
	HUF_PUBLIC_API unsigned HUF_isError(size_t code); /*< tells if a return value is an error code /
	HUF_PUBLIC_API const char* HUF_getErrorName(size_t code); /*< provides error code string (useful for debugging) /


	/* * Advanced function * */

	/** HUF_compress2() :
	* Same as HUF_compress(), but offers control over `maxSymbolValue` and `tableLog`.
	* `maxSymbolValue` must be <= HUF_SYMBOLVALUE_MAX .
	* `tableLog` must be `<= HUF_TABLELOG_MAX` . */
	HUF_PUBLIC_API size_t HUF_compress2 (void* dst, size_t dstCapacity,
	const void* src, size_t srcSize,
	unsigned maxSymbolValue, unsigned tableLog);

	/** HUF_compress4X_wksp() :
	* Same as HUF_compress2(), but uses externally allocated `workSpace`.
	* `workspace` must have minimum alignment of 4, and be at least as large as HUF_WORKSPACE_SIZE */
	#define HUF_WORKSPACE_SIZE ((6 << 10) + 256)
	#define HUF_WORKSPACE_SIZE_U32 (HUF_WORKSPACE_SIZE / sizeof(U32))
	HUF_PUBLIC_API size_t HUF_compress4X_wksp (void* dst, size_t dstCapacity,
	const void* src, size_t srcSize,
	unsigned maxSymbolValue, unsigned tableLog,
	void* workSpace, size_t wkspSize);

	#endif /* HUF_H_298734234 */

	/* ******************************************************************
	* WARNING !!
	* The following section contains advanced and experimental definitions
	* which shall never be used in the context of a dynamic library,
	* because they are not guaranteed to remain stable in the future.
	* Only consider them in association with static linking.
	* *****************************************************************/
	#if defined(HUF_STATIC_LINKING_ONLY) && !defined(HUF_H_HUF_STATIC_LINKING_ONLY)
	#define HUF_H_HUF_STATIC_LINKING_ONLY

	/* * Dependencies * */
	/** skipping file: mem.h **/


	/* * Constants * */
	#define HUF_TABLELOG_MAX 12 /* max runtime value of tableLog (due to static allocation); can be modified up to HUF_ABSOLUTEMAX_TABLELOG */
	#define HUF_TABLELOG_DEFAULT 11 /* default tableLog value when none specified */
	#define HUF_SYMBOLVALUE_MAX 255

	#define HUF_TABLELOG_ABSOLUTEMAX 15 /* absolute limit of HUF_MAX_TABLELOG. Beyond that value, code does not work */
	#if (HUF_TABLELOG_MAX > HUF_TABLELOG_ABSOLUTEMAX)
	# error "HUF_TABLELOG_MAX is too large !"
	#endif


	/* ****************************************
	* Static allocation
	******************************************/
	/* HUF buffer bounds */
	#define HUF_CTABLEBOUND 129
	#define HUF_BLOCKBOUND(size) (size + (size>>8) + 8) /* only true when incompressible is pre-filtered with fast heuristic */
	#define HUF_COMPRESSBOUND(size) (HUF_CTABLEBOUND + HUF_BLOCKBOUND(size)) /* Macro version, useful for static allocation */

	/* static allocation of HUF's Compression Table */
	#define HUF_CTABLE_SIZE_U32(maxSymbolValue) ((maxSymbolValue)+1) /* Use tables of U32, for proper alignment */
	#define HUF_CTABLE_SIZE(maxSymbolValue) (HUF_CTABLE_SIZE_U32(maxSymbolValue) * sizeof(U32))
	#define HUF_CREATE_STATIC_CTABLE(name, maxSymbolValue) \
	U32 name##hb[HUF_CTABLE_SIZE_U32(maxSymbolValue)]; \
	void* name##hv = &(name##hb); \
	HUF_CElt* name = (HUF_CElt)(name##hv) / no final ; */

	/* static allocation of HUF's DTable */
	typedef U32 HUF_DTable;
	#define HUF_DTABLE_SIZE(maxTableLog) (1 + (1<<(maxTableLog)))
	#define HUF_CREATE_STATIC_DTABLEX1(DTable, maxTableLog) \
	HUF_DTable DTable[HUF_DTABLE_SIZE((maxTableLog)-1)] = { ((U32)((maxTableLog)-1) * 0x01000001) }
	#define HUF_CREATE_STATIC_DTABLEX2(DTable, maxTableLog) \
	HUF_DTable DTable[HUF_DTABLE_SIZE(maxTableLog)] = { ((U32)(maxTableLog) * 0x01000001) }


	/* ****************************************
	* Advanced decompression functions
	******************************************/
	size_t HUF_decompress4X1 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /*< single-symbol decoder /
	#ifndef HUF_FORCE_DECOMPRESS_X1
	size_t HUF_decompress4X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /*< double-symbols decoder /
	#endif

	size_t HUF_decompress4X_DCtx (HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /*< decodes RLE and uncompressed /
	size_t HUF_decompress4X_hufOnly(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /*< considers RLE and uncompressed as errors /
	size_t HUF_decompress4X_hufOnly_wksp(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize); /*< considers RLE and uncompressed as errors /
	size_t HUF_decompress4X1_DCtx(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /*< single-symbol decoder /
	size_t HUF_decompress4X1_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize); /*< single-symbol decoder /
	#ifndef HUF_FORCE_DECOMPRESS_X1
	size_t HUF_decompress4X2_DCtx(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /*< double-symbols decoder /
	size_t HUF_decompress4X2_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize); /*< double-symbols decoder /
	#endif


	/* ****************************************
	* HUF detailed API
	* ****************************************/

	/*! HUF_compress() does the following:
	* 1. count symbol occurrence from source[] into table count[] using FSE_count() (exposed within "fse.h")
	* 2. (optional) refine tableLog using HUF_optimalTableLog()
	* 3. build Huffman table from count using HUF_buildCTable()
	* 4. save Huffman table to memory buffer using HUF_writeCTable()
	* 5. encode the data stream using HUF_compress4X_usingCTable()
	*
	* The following API allows targeting specific sub-functions for advanced tasks.
	* For example, it's possible to compress several blocks using the same 'CTable',
	* or to save and regenerate 'CTable' using external methods.
	*/
	unsigned HUF_optimalTableLog(unsigned maxTableLog, size_t srcSize, unsigned maxSymbolValue);
	typedef struct HUF_CElt_s HUF_CElt; /* incomplete type */
	size_t HUF_buildCTable (HUF_CElt* CTable, const unsigned* count, unsigned maxSymbolValue, unsigned maxNbBits); /* @return : maxNbBits; CTable and count can overlap. In which case, CTable will overwrite count content */
	size_t HUF_writeCTable (void* dst, size_t maxDstSize, const HUF_CElt* CTable, unsigned maxSymbolValue, unsigned huffLog);
	size_t HUF_compress4X_usingCTable(void* dst, size_t dstSize, const void* src, size_t srcSize, const HUF_CElt* CTable);
	size_t HUF_estimateCompressedSize(const HUF_CElt* CTable, const unsigned* count, unsigned maxSymbolValue);
	int HUF_validateCTable(const HUF_CElt* CTable, const unsigned* count, unsigned maxSymbolValue);

	typedef enum {
	HUF_repeat_none, /*< Cannot use the previous table /
	HUF_repeat_check, /*< Can use the previous table but it must be checked. Note : The previous table must have been constructed by HUF_compress{1, 4}X_repeat /
	HUF_repeat_valid /*< Can use the previous table and it is assumed to be valid /
	} HUF_repeat;
	/** HUF_compress4X_repeat() :
	* Same as HUF_compress4X_wksp(), but considers using hufTable if *repeat != HUF_repeat_none.
	* If it uses hufTable it does not modify hufTable or repeat.
	* If it doesn't, it sets *repeat = HUF_repeat_none, and it sets hufTable to the table used.
	* If preferRepeat then the old table will always be used if valid. */
	size_t HUF_compress4X_repeat(void* dst, size_t dstSize,
	const void* src, size_t srcSize,
	unsigned maxSymbolValue, unsigned tableLog,
	void* workSpace, size_t wkspSize, /*< `workSpace` must be aligned on 4-bytes boundaries, `wkspSize` must be >= HUF_WORKSPACE_SIZE /
	HUF_CElt* hufTable, HUF_repeat* repeat, int preferRepeat, int bmi2);

	/** HUF_buildCTable_wksp() :
	* Same as HUF_buildCTable(), but using externally allocated scratch buffer.
	* `workSpace` must be aligned on 4-bytes boundaries, and its size must be >= HUF_CTABLE_WORKSPACE_SIZE.
	*/
	#define HUF_CTABLE_WORKSPACE_SIZE_U32 (2*HUF_SYMBOLVALUE_MAX +1 +1)
	#define HUF_CTABLE_WORKSPACE_SIZE (HUF_CTABLE_WORKSPACE_SIZE_U32 * sizeof(unsigned))
	size_t HUF_buildCTable_wksp (HUF_CElt* tree,
	const unsigned* count, U32 maxSymbolValue, U32 maxNbBits,
	void* workSpace, size_t wkspSize);

	/*! HUF_readStats() :
	* Read compact Huffman tree, saved by HUF_writeCTable().
	* `huffWeight` is destination buffer.
	* @return : size read from `src` , or an error Code .
	* Note : Needed by HUF_readCTable() and HUF_readDTableXn() . */
	size_t HUF_readStats(BYTE* huffWeight, size_t hwSize,
	U32* rankStats, U32* nbSymbolsPtr, U32* tableLogPtr,
	const void* src, size_t srcSize);

	/** HUF_readCTable() :
	* Loading a CTable saved with HUF_writeCTable() */
	size_t HUF_readCTable (HUF_CElt* CTable, unsigned* maxSymbolValuePtr, const void* src, size_t srcSize, unsigned *hasZeroWeights);

	/** HUF_getNbBits() :
	* Read nbBits from CTable symbolTable, for symbol `symbolValue` presumed <= HUF_SYMBOLVALUE_MAX
	* Note 1 : is not inlined, as HUF_CElt definition is private
	* Note 2 : const void* used, so that it can provide a statically allocated table as argument (which uses type U32) */
	U32 HUF_getNbBits(const void* symbolTable, U32 symbolValue);

	/*
	* HUF_decompress() does the following:
	* 1. select the decompression algorithm (X1, X2) based on pre-computed heuristics
	* 2. build Huffman table from save, using HUF_readDTableX?()
	* 3. decode 1 or 4 segments in parallel using HUF_decompress?X?_usingDTable()
	*/

	/** HUF_selectDecoder() :
	* Tells which decoder is likely to decode faster,
	* based on a set of pre-computed metrics.
	* @return : 0==HUF_decompress4X1, 1==HUF_decompress4X2 .
	* Assumption : 0 < dstSize <= 128 KB */
	U32 HUF_selectDecoder (size_t dstSize, size_t cSrcSize);

	/**
	* The minimum workspace size for the `workSpace` used in
	* HUF_readDTableX1_wksp() and HUF_readDTableX2_wksp().
	*
	* The space used depends on HUF_TABLELOG_MAX, ranging from ~1500 bytes when
	* HUF_TABLE_LOG_MAX=12 to ~1850 bytes when HUF_TABLE_LOG_MAX=15.
	* Buffer overflow errors may potentially occur if code modifications result in
	* a required workspace size greater than that specified in the following
	* macro.
	*/
	#define HUF_DECOMPRESS_WORKSPACE_SIZE (2 << 10)
	#define HUF_DECOMPRESS_WORKSPACE_SIZE_U32 (HUF_DECOMPRESS_WORKSPACE_SIZE / sizeof(U32))

	#ifndef HUF_FORCE_DECOMPRESS_X2
	size_t HUF_readDTableX1 (HUF_DTable* DTable, const void* src, size_t srcSize);
	size_t HUF_readDTableX1_wksp (HUF_DTable* DTable, const void* src, size_t srcSize, void* workSpace, size_t wkspSize);
	#endif
	#ifndef HUF_FORCE_DECOMPRESS_X1
	size_t HUF_readDTableX2 (HUF_DTable* DTable, const void* src, size_t srcSize);
	size_t HUF_readDTableX2_wksp (HUF_DTable* DTable, const void* src, size_t srcSize, void* workSpace, size_t wkspSize);
	#endif

	size_t HUF_decompress4X_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable);
	#ifndef HUF_FORCE_DECOMPRESS_X2
	size_t HUF_decompress4X1_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable);
	#endif
	#ifndef HUF_FORCE_DECOMPRESS_X1
	size_t HUF_decompress4X2_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable);
	#endif


	/* ====================== */
	/* single stream variants */
	/* ====================== */

	size_t HUF_compress1X (void* dst, size_t dstSize, const void* src, size_t srcSize, unsigned maxSymbolValue, unsigned tableLog);
	size_t HUF_compress1X_wksp (void* dst, size_t dstSize, const void* src, size_t srcSize, unsigned maxSymbolValue, unsigned tableLog, void* workSpace, size_t wkspSize); /*< `workSpace` must be a table of at least HUF_WORKSPACE_SIZE_U32 unsigned /
	size_t HUF_compress1X_usingCTable(void* dst, size_t dstSize, const void* src, size_t srcSize, const HUF_CElt* CTable);
	/** HUF_compress1X_repeat() :
	* Same as HUF_compress1X_wksp(), but considers using hufTable if *repeat != HUF_repeat_none.
	* If it uses hufTable it does not modify hufTable or repeat.
	* If it doesn't, it sets *repeat = HUF_repeat_none, and it sets hufTable to the table used.
	* If preferRepeat then the old table will always be used if valid. */
	size_t HUF_compress1X_repeat(void* dst, size_t dstSize,
	const void* src, size_t srcSize,
	unsigned maxSymbolValue, unsigned tableLog,
	void* workSpace, size_t wkspSize, /*< `workSpace` must be aligned on 4-bytes boundaries, `wkspSize` must be >= HUF_WORKSPACE_SIZE /
	HUF_CElt* hufTable, HUF_repeat* repeat, int preferRepeat, int bmi2);

	size_t HUF_decompress1X1 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /* single-symbol decoder */
	#ifndef HUF_FORCE_DECOMPRESS_X1
	size_t HUF_decompress1X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /* double-symbol decoder */
	#endif

	size_t HUF_decompress1X_DCtx (HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);
	size_t HUF_decompress1X_DCtx_wksp (HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize);
	#ifndef HUF_FORCE_DECOMPRESS_X2
	size_t HUF_decompress1X1_DCtx(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /*< single-symbol decoder /
	size_t HUF_decompress1X1_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize); /*< single-symbol decoder /
	#endif
	#ifndef HUF_FORCE_DECOMPRESS_X1
	size_t HUF_decompress1X2_DCtx(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /*< double-symbols decoder /
	size_t HUF_decompress1X2_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize); /*< double-symbols decoder /
	#endif

	size_t HUF_decompress1X_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable); /*< automatic selection of sing or double symbol decoder, based on DTable /
	#ifndef HUF_FORCE_DECOMPRESS_X2
	size_t HUF_decompress1X1_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable);
	#endif
	#ifndef HUF_FORCE_DECOMPRESS_X1
	size_t HUF_decompress1X2_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable);
	#endif

	/* BMI2 variants.
	* If the CPU has BMI2 support, pass bmi2=1, otherwise pass bmi2=0.
	*/
	size_t HUF_decompress1X_usingDTable_bmi2(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable, int bmi2);
	#ifndef HUF_FORCE_DECOMPRESS_X2
	size_t HUF_decompress1X1_DCtx_wksp_bmi2(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize, int bmi2);
	#endif
	size_t HUF_decompress4X_usingDTable_bmi2(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable, int bmi2);
	size_t HUF_decompress4X_hufOnly_wksp_bmi2(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize, int bmi2);

	#endif /* HUF_STATIC_LINKING_ONLY */

	#if defined (__cplusplus)
	}
	#endif
	/** ended inlining huf.h **/


	/=== Version ===/
	unsigned FSE_versionNumber(void) { return FSE_VERSION_NUMBER; }


	/=== Error Management ===/
	unsigned FSE_isError(size_t code) { return ERR_isError(code); }
	const char* FSE_getErrorName(size_t code) { return ERR_getErrorName(code); }

	unsigned HUF_isError(size_t code) { return ERR_isError(code); }
	const char* HUF_getErrorName(size_t code) { return ERR_getErrorName(code); }


	/-*************************************************************
	* FSE NCount encoding-decoding
	****************************************************************/
	size_t FSE_readNCount (short* normalizedCounter, unsigned* maxSVPtr, unsigned* tableLogPtr,
	const void* headerBuffer, size_t hbSize)
	{
	const BYTE* const istart = (const BYTE*) headerBuffer;
	const BYTE* const iend = istart + hbSize;
	const BYTE* ip = istart;
	int nbBits;
	int remaining;
	int threshold;
	U32 bitStream;
	int bitCount;
	unsigned charnum = 0;
	int previous0 = 0;

	if (hbSize < 4) {
	/* This function only works when hbSize >= 4 */
	char buffer[4];
	memset(buffer, 0, sizeof(buffer));
	memcpy(buffer, headerBuffer, hbSize);
	{ size_t const countSize = FSE_readNCount(normalizedCounter, maxSVPtr, tableLogPtr,
	buffer, sizeof(buffer));
	if (FSE_isError(countSize)) return countSize;
	if (countSize > hbSize) return ERROR(corruption_detected);
	return countSize;
	} }
	assert(hbSize >= 4);

	/* init */
	memset(normalizedCounter, 0, (maxSVPtr+1) sizeof(normalizedCounter[0])); /* all symbols not present in NCount have a frequency of 0 */
	bitStream = MEM_readLE32(ip);
	nbBits = (bitStream & 0xF) + FSE_MIN_TABLELOG; /* extract tableLog */
	if (nbBits > FSE_TABLELOG_ABSOLUTE_MAX) return ERROR(tableLog_tooLarge);
	bitStream >>= 4;
	bitCount = 4;
	*tableLogPtr = nbBits;
	remaining = (1<<nbBits)+1;
	threshold = 1<<nbBits;
	nbBits++;

	while ((remaining>1) & (charnum<=*maxSVPtr)) {
	if (previous0) {
	unsigned n0 = charnum;
	while ((bitStream & 0xFFFF) == 0xFFFF) {
	n0 += 24;
	if (ip < iend-5) {
	ip += 2;
	bitStream = MEM_readLE32(ip) >> bitCount;
	} else {
	bitStream >>= 16;
	bitCount += 16;
	} }
	while ((bitStream & 3) == 3) {
	n0 += 3;
	bitStream >>= 2;
	bitCount += 2;
	}
	n0 += bitStream & 3;
	bitCount += 2;
	if (n0 > *maxSVPtr) return ERROR(maxSymbolValue_tooSmall);
	while (charnum < n0) normalizedCounter[charnum++] = 0;
	if ((ip <= iend-7) \|\| (ip + (bitCount>>3) <= iend-4)) {
	assert((bitCount >> 3) <= 3); /* For first condition to work */
	ip += bitCount>>3;
	bitCount &= 7;
	bitStream = MEM_readLE32(ip) >> bitCount;
	} else {
	bitStream >>= 2;
	} }
	{ int const max = (2*threshold-1) - remaining;
	int count;

	if ((bitStream & (threshold-1)) < (U32)max) {
	count = bitStream & (threshold-1);
	bitCount += nbBits-1;
	} else {
	count = bitStream & (2*threshold-1);
	if (count >= threshold) count -= max;
	bitCount += nbBits;
	}

	count--; /* extra accuracy */
	remaining -= count < 0 ? -count : count; /* -1 means +1 */
	normalizedCounter[charnum++] = (short)count;
	previous0 = !count;
	while (remaining < threshold) {
	nbBits--;
	threshold >>= 1;
	}

	if ((ip <= iend-7) \|\| (ip + (bitCount>>3) <= iend-4)) {
	ip += bitCount>>3;
	bitCount &= 7;
	} else {
	bitCount -= (int)(8 * (iend - 4 - ip));
	ip = iend - 4;
	}
	bitStream = MEM_readLE32(ip) >> (bitCount & 31);
	} } /* while ((remaining>1) & (charnum<=maxSVPtr)) /
	if (remaining != 1) return ERROR(corruption_detected);
	if (bitCount > 32) return ERROR(corruption_detected);
	*maxSVPtr = charnum-1;

	ip += (bitCount+7)>>3;
	return ip-istart;
	}


	/*! HUF_readStats() :
	Read compact Huffman tree, saved by HUF_writeCTable().
	`huffWeight` is destination buffer.
	`rankStats` is assumed to be a table of at least HUF_TABLELOG_MAX U32.
	@return : size read from `src` , or an error Code .
	Note : Needed by HUF_readCTable() and HUF_readDTableX?() .
	*/
	size_t HUF_readStats(BYTE* huffWeight, size_t hwSize, U32* rankStats,
	U32* nbSymbolsPtr, U32* tableLogPtr,
	const void* src, size_t srcSize)
	{
	U32 weightTotal;
	const BYTE* ip = (const BYTE*) src;
	size_t iSize;
	size_t oSize;

	if (!srcSize) return ERROR(srcSize_wrong);
	iSize = ip[0];
	/* memset(huffWeight, 0, hwSize); // is not necessary, even though some analyzer complain ... */

	if (iSize >= 128) { /* special header */
	oSize = iSize - 127;
	iSize = ((oSize+1)/2);
	if (iSize+1 > srcSize) return ERROR(srcSize_wrong);
	if (oSize >= hwSize) return ERROR(corruption_detected);
	ip += 1;
	{ U32 n;
	for (n=0; n<oSize; n+=2) {
	huffWeight[n] = ip[n/2] >> 4;
	huffWeight[n+1] = ip[n/2] & 15;
	} } }
	else { /* header compressed with FSE (normal case) */
	FSE_DTable fseWorkspace[FSE_DTABLE_SIZE_U32(6)]; /* 6 is max possible tableLog for HUF header (maybe even 5, to be tested) */
	if (iSize+1 > srcSize) return ERROR(srcSize_wrong);
	oSize = FSE_decompress_wksp(huffWeight, hwSize-1, ip+1, iSize, fseWorkspace, 6); /* max (hwSize-1) values decoded, as last one is implied */
	if (FSE_isError(oSize)) return oSize;
	}

	/* collect weight stats */
	memset(rankStats, 0, (HUF_TABLELOG_MAX + 1) * sizeof(U32));
	weightTotal = 0;
	{ U32 n; for (n=0; n<oSize; n++) {
	if (huffWeight[n] >= HUF_TABLELOG_MAX) return ERROR(corruption_detected);
	rankStats[huffWeight[n]]++;
	weightTotal += (1 << huffWeight[n]) >> 1;
	} }
	if (weightTotal == 0) return ERROR(corruption_detected);

	/* get last non-null symbol weight (implied, total must be 2^n) */
	{ U32 const tableLog = BIT_highbit32(weightTotal) + 1;
	if (tableLog > HUF_TABLELOG_MAX) return ERROR(corruption_detected);
	*tableLogPtr = tableLog;
	/* determine last weight */
	{ U32 const total = 1 << tableLog;
	U32 const rest = total - weightTotal;
	U32 const verif = 1 << BIT_highbit32(rest);
	U32 const lastWeight = BIT_highbit32(rest) + 1;
	if (verif != rest) return ERROR(corruption_detected); /* last value must be a clean power of 2 */
	huffWeight[oSize] = (BYTE)lastWeight;
	rankStats[lastWeight]++;
	} }

	/* check tree construction validity */
	if ((rankStats[1] < 2) \|\| (rankStats[1] & 1)) return ERROR(corruption_detected); /* by construction : at least 2 elts of rank 1, must be even */

	/* results */
	*nbSymbolsPtr = (U32)(oSize+1);
	return iSize+1;
	}
	/** ended inlining common/entropy_common.c **/
	/** start inlining common/error_private.c **/
	/*
	* Copyright (c) 2016-2020, Yann Collet, Facebook, Inc.
	* All rights reserved.
	*
	* This source code is licensed under both the BSD-style license (found in the
	* LICENSE file in the root directory of this source tree) and the GPLv2 (found
	* in the COPYING file in the root directory of this source tree).
	* You may select, at your option, one of the above-listed licenses.
	*/

	/* The purpose of this file is to have a single list of error strings embedded in binary */

	/** skipping file: error_private.h **/

	const char* ERR_getErrorString(ERR_enum code)
	{
	#ifdef ZSTD_STRIP_ERROR_STRINGS
	(void)code;
	return "Error strings stripped";
	#else
	static const char* const notErrorCode = "Unspecified error code";
	switch( code )
	{
	case PREFIX(no_error): return "No error detected";
	case PREFIX(GENERIC): return "Error (generic)";
	case PREFIX(prefix_unknown): return "Unknown frame descriptor";
	case PREFIX(version_unsupported): return "Version not supported";
	case PREFIX(frameParameter_unsupported): return "Unsupported frame parameter";
	case PREFIX(frameParameter_windowTooLarge): return "Frame requires too much memory for decoding";
	case PREFIX(corruption_detected): return "Corrupted block detected";
	case PREFIX(checksum_wrong): return "Restored data doesn't match checksum";
	case PREFIX(parameter_unsupported): return "Unsupported parameter";
	case PREFIX(parameter_outOfBound): return "Parameter is out of bound";
	case PREFIX(init_missing): return "Context should be init first";
	case PREFIX(memory_allocation): return "Allocation error : not enough memory";
	case PREFIX(workSpace_tooSmall): return "workSpace buffer is not large enough";
	case PREFIX(stage_wrong): return "Operation not authorized at current processing stage";
	case PREFIX(tableLog_tooLarge): return "tableLog requires too much memory : unsupported";
	case PREFIX(maxSymbolValue_tooLarge): return "Unsupported max Symbol Value : too large";
	case PREFIX(maxSymbolValue_tooSmall): return "Specified maxSymbolValue is too small";
	case PREFIX(dictionary_corrupted): return "Dictionary is corrupted";
	case PREFIX(dictionary_wrong): return "Dictionary mismatch";
	case PREFIX(dictionaryCreation_failed): return "Cannot create Dictionary from provided samples";
	case PREFIX(dstSize_tooSmall): return "Destination buffer is too small";
	case PREFIX(srcSize_wrong): return "Src size is incorrect";
	case PREFIX(dstBuffer_null): return "Operation on NULL destination buffer";
	/* following error codes are not stable and may be removed or changed in a future version */
	case PREFIX(frameIndex_tooLarge): return "Frame index is too large";
	case PREFIX(seekableIO): return "An I/O error occurred when reading/seeking";
	case PREFIX(dstBuffer_wrong): return "Destination buffer is wrong";
	case PREFIX(maxCode):
	default: return notErrorCode;
	}
	#endif
	}
	/** ended inlining common/error_private.c **/
	/** start inlining common/fse_decompress.c **/
	/* ******************************************************************
	* FSE : Finite State Entropy decoder
	* Copyright (c) 2013-2020, Yann Collet, Facebook, Inc.
	*
	* You can contact the author at :
	* - FSE source repository : https://github.com/Cyan4973/FiniteStateEntropy
	* - Public forum : https://groups.google.com/forum/#!forum/lz4c
	*
	* This source code is licensed under both the BSD-style license (found in the
	* LICENSE file in the root directory of this source tree) and the GPLv2 (found
	* in the COPYING file in the root directory of this source tree).
	* You may select, at your option, one of the above-listed licenses.
	****************************************************************** */


	/* **************************************************************
	* Includes
	****************************************************************/
	#include <stdlib.h> /* malloc, free, qsort */
	#include <string.h> /* memcpy, memset */
	/** skipping file: bitstream.h **/
	/** skipping file: compiler.h **/
	#define FSE_STATIC_LINKING_ONLY
	/** skipping file: fse.h **/
	/** skipping file: error_private.h **/


	/* **************************************************************
	* Error Management
	****************************************************************/
	#define FSE_isError ERR_isError
	#define FSE_STATIC_ASSERT(c) DEBUG_STATIC_ASSERT(c) /* use only after variable declarations */


	/* **************************************************************
	* Templates
	****************************************************************/
	/*
	designed to be included
	for type-specific functions (template emulation in C)
	Objective is to write these functions only once, for improved maintenance
	*/

	/* safety checks */
	#ifndef FSE_FUNCTION_EXTENSION
	# error "FSE_FUNCTION_EXTENSION must be defined"
	#endif
	#ifndef FSE_FUNCTION_TYPE
	# error "FSE_FUNCTION_TYPE must be defined"
	#endif

	/* Function names */
	#define FSE_CAT(X,Y) X##Y
	#define FSE_FUNCTION_NAME(X,Y) FSE_CAT(X,Y)
	#define FSE_TYPE_NAME(X,Y) FSE_CAT(X,Y)


	/* Function templates */
	FSE_DTable* FSE_createDTable (unsigned tableLog)
	{
	if (tableLog > FSE_TABLELOG_ABSOLUTE_MAX) tableLog = FSE_TABLELOG_ABSOLUTE_MAX;
	return (FSE_DTable)malloc( FSE_DTABLE_SIZE_U32(tableLog) sizeof (U32) );
	}

	void FSE_freeDTable (FSE_DTable* dt)
	{
	free(dt);
	}

	size_t FSE_buildDTable(FSE_DTable* dt, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog)
	{
	void* const tdPtr = dt+1; /* because dt is unsigned, 32-bits aligned on 32-bits /
	FSE_DECODE_TYPE* const tableDecode = (FSE_DECODE_TYPE*) (tdPtr);
	U16 symbolNext[FSE_MAX_SYMBOL_VALUE+1];

	U32 const maxSV1 = maxSymbolValue + 1;
	U32 const tableSize = 1 << tableLog;
	U32 highThreshold = tableSize-1;

	/* Sanity Checks */
	if (maxSymbolValue > FSE_MAX_SYMBOL_VALUE) return ERROR(maxSymbolValue_tooLarge);
	if (tableLog > FSE_MAX_TABLELOG) return ERROR(tableLog_tooLarge);

	/* Init, lay down lowprob symbols */
	{ FSE_DTableHeader DTableH;
	DTableH.tableLog = (U16)tableLog;
	DTableH.fastMode = 1;
	{ S16 const largeLimit= (S16)(1 << (tableLog-1));
	U32 s;
	for (s=0; s<maxSV1; s++) {
	if (normalizedCounter[s]==-1) {
	tableDecode[highThreshold--].symbol = (FSE_FUNCTION_TYPE)s;
	symbolNext[s] = 1;
	} else {
	if (normalizedCounter[s] >= largeLimit) DTableH.fastMode=0;
	symbolNext[s] = normalizedCounter[s];
	} } }
	memcpy(dt, &DTableH, sizeof(DTableH));
	}

	/* Spread symbols */
	{ U32 const tableMask = tableSize-1;
	U32 const step = FSE_TABLESTEP(tableSize);
	U32 s, position = 0;
	for (s=0; s<maxSV1; s++) {
	int i;
	for (i=0; i<normalizedCounter[s]; i++) {
	tableDecode[position].symbol = (FSE_FUNCTION_TYPE)s;
	position = (position + step) & tableMask;
	while (position > highThreshold) position = (position + step) & tableMask; /* lowprob area */
	} }
	if (position!=0) return ERROR(GENERIC); /* position must reach all cells once, otherwise normalizedCounter is incorrect */
	}

	/* Build Decoding table */
	{ U32 u;
	for (u=0; u<tableSize; u++) {
	FSE_FUNCTION_TYPE const symbol = (FSE_FUNCTION_TYPE)(tableDecode[u].symbol);
	U32 const nextState = symbolNext[symbol]++;
	tableDecode[u].nbBits = (BYTE) (tableLog - BIT_highbit32(nextState) );
	tableDecode[u].newState = (U16) ( (nextState << tableDecode[u].nbBits) - tableSize);
	} }

	return 0;
	}


	#ifndef FSE_COMMONDEFS_ONLY

	/-******************************************************
	* Decompression (Byte symbols)
	*********************************************************/
	size_t FSE_buildDTable_rle (FSE_DTable* dt, BYTE symbolValue)
	{
	void* ptr = dt;
	FSE_DTableHeader* const DTableH = (FSE_DTableHeader*)ptr;
	void* dPtr = dt + 1;
	FSE_decode_t* const cell = (FSE_decode_t*)dPtr;

	DTableH->tableLog = 0;
	DTableH->fastMode = 0;

	cell->newState = 0;
	cell->symbol = symbolValue;
	cell->nbBits = 0;

	return 0;
	}


	size_t FSE_buildDTable_raw (FSE_DTable* dt, unsigned nbBits)
	{
	void* ptr = dt;
	FSE_DTableHeader* const DTableH = (FSE_DTableHeader*)ptr;
	void* dPtr = dt + 1;
	FSE_decode_t* const dinfo = (FSE_decode_t*)dPtr;
	const unsigned tableSize = 1 << nbBits;
	const unsigned tableMask = tableSize - 1;
	const unsigned maxSV1 = tableMask+1;
	unsigned s;

	/* Sanity checks */
	if (nbBits < 1) return ERROR(GENERIC); /* min size */

	/* Build Decoding Table */
	DTableH->tableLog = (U16)nbBits;
	DTableH->fastMode = 1;
	for (s=0; s<maxSV1; s++) {
	dinfo[s].newState = 0;
	dinfo[s].symbol = (BYTE)s;
	dinfo[s].nbBits = (BYTE)nbBits;
	}

	return 0;
	}

	FORCE_INLINE_TEMPLATE size_t FSE_decompress_usingDTable_generic(
	void* dst, size_t maxDstSize,
	const void* cSrc, size_t cSrcSize,
	const FSE_DTable* dt, const unsigned fast)
	{
	BYTE* const ostart = (BYTE*) dst;
	BYTE* op = ostart;
	BYTE* const omax = op + maxDstSize;
	BYTE* const olimit = omax-3;

	BIT_DStream_t bitD;
	FSE_DState_t state1;
	FSE_DState_t state2;

	/* Init */
	CHECK_F(BIT_initDStream(&bitD, cSrc, cSrcSize));

	FSE_initDState(&state1, &bitD, dt);
	FSE_initDState(&state2, &bitD, dt);

	#define FSE_GETSYMBOL(statePtr) fast ? FSE_decodeSymbolFast(statePtr, &bitD) : FSE_decodeSymbol(statePtr, &bitD)

	/* 4 symbols per loop */
	for ( ; (BIT_reloadDStream(&bitD)==BIT_DStream_unfinished) & (op<olimit) ; op+=4) {
	op[0] = FSE_GETSYMBOL(&state1);

	if (FSE_MAX_TABLELOG2+7 > sizeof(bitD.bitContainer)8) /* This test must be static */
	BIT_reloadDStream(&bitD);

	op[1] = FSE_GETSYMBOL(&state2);

	if (FSE_MAX_TABLELOG4+7 > sizeof(bitD.bitContainer)8) /* This test must be static */
	{ if (BIT_reloadDStream(&bitD) > BIT_DStream_unfinished) { op+=2; break; } }

	op[2] = FSE_GETSYMBOL(&state1);

	if (FSE_MAX_TABLELOG2+7 > sizeof(bitD.bitContainer)8) /* This test must be static */
	BIT_reloadDStream(&bitD);

	op[3] = FSE_GETSYMBOL(&state2);
	}

	/* tail */
	/* note : BIT_reloadDStream(&bitD) >= FSE_DStream_partiallyFilled; Ends at exactly BIT_DStream_completed */
	while (1) {
	if (op>(omax-2)) return ERROR(dstSize_tooSmall);
	*op++ = FSE_GETSYMBOL(&state1);
	if (BIT_reloadDStream(&bitD)==BIT_DStream_overflow) {
	*op++ = FSE_GETSYMBOL(&state2);
	break;
	}

	if (op>(omax-2)) return ERROR(dstSize_tooSmall);
	*op++ = FSE_GETSYMBOL(&state2);
	if (BIT_reloadDStream(&bitD)==BIT_DStream_overflow) {
	*op++ = FSE_GETSYMBOL(&state1);
	break;
	} }

	return op-ostart;
	}


	size_t FSE_decompress_usingDTable(void* dst, size_t originalSize,
	const void* cSrc, size_t cSrcSize,
	const FSE_DTable* dt)
	{
	const void* ptr = dt;
	const FSE_DTableHeader* DTableH = (const FSE_DTableHeader*)ptr;
	const U32 fastMode = DTableH->fastMode;

	/* select fast mode (static) */
	if (fastMode) return FSE_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 1);
	return FSE_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 0);
	}


	size_t FSE_decompress_wksp(void* dst, size_t dstCapacity, const void* cSrc, size_t cSrcSize, FSE_DTable* workSpace, unsigned maxLog)
	{
	const BYTE* const istart = (const BYTE*)cSrc;
	const BYTE* ip = istart;
	short counting[FSE_MAX_SYMBOL_VALUE+1];
	unsigned tableLog;
	unsigned maxSymbolValue = FSE_MAX_SYMBOL_VALUE;

	/* normal FSE decoding mode */
	size_t const NCountLength = FSE_readNCount (counting, &maxSymbolValue, &tableLog, istart, cSrcSize);
	if (FSE_isError(NCountLength)) return NCountLength;
	/* if (NCountLength >= cSrcSize) return ERROR(srcSize_wrong); / / too small input size; supposed to be already checked in NCountLength, only remaining case : NCountLength==cSrcSize */
	if (tableLog > maxLog) return ERROR(tableLog_tooLarge);
	ip += NCountLength;
	cSrcSize -= NCountLength;

	CHECK_F( FSE_buildDTable (workSpace, counting, maxSymbolValue, tableLog) );

	return FSE_decompress_usingDTable (dst, dstCapacity, ip, cSrcSize, workSpace); /* always return, even if it is an error code */
	}


	typedef FSE_DTable DTable_max_t[FSE_DTABLE_SIZE_U32(FSE_MAX_TABLELOG)];

	size_t FSE_decompress(void* dst, size_t dstCapacity, const void* cSrc, size_t cSrcSize)
	{
	DTable_max_t dt; /* Static analyzer seems unable to understand this table will be properly initialized later */
	return FSE_decompress_wksp(dst, dstCapacity, cSrc, cSrcSize, dt, FSE_MAX_TABLELOG);
	}



	#endif /* FSE_COMMONDEFS_ONLY */
	/** ended inlining common/fse_decompress.c **/
	/** start inlining common/pool.c **/
	/*
	* Copyright (c) 2016-2020, Yann Collet, Facebook, Inc.
	* All rights reserved.
	*
	* This source code is licensed under both the BSD-style license (found in the
	* LICENSE file in the root directory of this source tree) and the GPLv2 (found
	* in the COPYING file in the root directory of this source tree).
	* You may select, at your option, one of the above-listed licenses.
	*/


	/* ====== Dependencies ======= */
	#include <stddef.h> /* size_t */
	/** skipping file: debug.h **/
	/** start inlining zstd_internal.h **/
	/*
	* Copyright (c) 2016-2020, Yann Collet, Facebook, Inc.
	* All rights reserved.
	*
	* This source code is licensed under both the BSD-style license (found in the
	* LICENSE file in the root directory of this source tree) and the GPLv2 (found
	* in the COPYING file in the root directory of this source tree).
	* You may select, at your option, one of the above-listed licenses.
	*/

	#ifndef ZSTD_CCOMMON_H_MODULE
	#define ZSTD_CCOMMON_H_MODULE

	/* this module contains definitions which must be identical
	* across compression, decompression and dictBuilder.
	* It also contains a few functions useful to at least 2 of them
	* and which benefit from being inlined */

	/-************************************
	* Dependencies
	***************************************/
	#if !defined(ZSTD_NO_INTRINSICS) && defined(__ARM_NEON)
	#include <arm_neon.h>
	#endif
	/** skipping file: compiler.h **/
	/** skipping file: mem.h **/
	/** skipping file: debug.h **/
	/** skipping file: error_private.h **/
	#define ZSTD_STATIC_LINKING_ONLY
	/** start inlining ../zstd.h **/
	/*
	* Copyright (c) 2016-2020, Yann Collet, Facebook, Inc.
	* All rights reserved.
	*
	* This source code is licensed under both the BSD-style license (found in the
	* LICENSE file in the root directory of this source tree) and the GPLv2 (found
	* in the COPYING file in the root directory of this source tree).
	* You may select, at your option, one of the above-listed licenses.
	*/
	#if defined (__cplusplus)
	extern "C" {
	#endif

	#ifndef ZSTD_H_235446
	#define ZSTD_H_235446

	/* ====== Dependency ======*/
	#include <limits.h> /* INT_MAX */
	#include <stddef.h> /* size_t */


	/* ===== ZSTDLIB_API : control library symbols visibility ===== */
	#ifndef ZSTDLIB_VISIBILITY
	# if defined(__GNUC__) && (__GNUC__ >= 4)
	# define ZSTDLIB_VISIBILITY __attribute__ ((visibility ("default")))
	# else
	# define ZSTDLIB_VISIBILITY
	# endif
	#endif
	#if defined(ZSTD_DLL_EXPORT) && (ZSTD_DLL_EXPORT==1)
	# define ZSTDLIB_API __declspec(dllexport) ZSTDLIB_VISIBILITY
	#elif defined(ZSTD_DLL_IMPORT) && (ZSTD_DLL_IMPORT==1)
	# define ZSTDLIB_API __declspec(dllimport) ZSTDLIB_VISIBILITY /* It isn't required but allows to generate better code, saving a function pointer load from the IAT and an indirect jump.*/
	#else
	# define ZSTDLIB_API ZSTDLIB_VISIBILITY
	#endif


	/*******************************************************************************
	Introduction

	zstd, short for Zstandard, is a fast lossless compression algorithm, targeting
	real-time compression scenarios at zlib-level and better compression ratios.
	The zstd compression library provides in-memory compression and decompression
	functions.

	The library supports regular compression levels from 1 up to ZSTD_maxCLevel(),
	which is currently 22. Levels >= 20, labeled `--ultra`, should be used with
	caution, as they require more memory. The library also offers negative
	compression levels, which extend the range of speed vs. ratio preferences.
	The lower the level, the faster the speed (at the cost of compression).

	Compression can be done in:
	- a single step (described as Simple API)
	- a single step, reusing a context (described as Explicit context)
	- unbounded multiple steps (described as Streaming compression)

	The compression ratio achievable on small data can be highly improved using
	a dictionary. Dictionary compression can be performed in:
	- a single step (described as Simple dictionary API)
	- a single step, reusing a dictionary (described as Bulk-processing
	dictionary API)

	Advanced experimental functions can be accessed using
	`#define ZSTD_STATIC_LINKING_ONLY` before including zstd.h.

	Advanced experimental APIs should never be used with a dynamically-linked
	library. They are not "stable"; their definitions or signatures may change in
	the future. Only static linking is allowed.
	*******************************************************************************/

	/------ Version ------/
	#define ZSTD_VERSION_MAJOR 1
	#define ZSTD_VERSION_MINOR 4
	#define ZSTD_VERSION_RELEASE 5

	#define ZSTD_VERSION_NUMBER (ZSTD_VERSION_MAJOR 100100 + ZSTD_VERSION_MINOR *100 + ZSTD_VERSION_RELEASE)
	ZSTDLIB_API unsigned ZSTD_versionNumber(void); /*< to check runtime library version /

	#define ZSTD_LIB_VERSION ZSTD_VERSION_MAJOR.ZSTD_VERSION_MINOR.ZSTD_VERSION_RELEASE
	#define ZSTD_QUOTE(str) #str
	#define ZSTD_EXPAND_AND_QUOTE(str) ZSTD_QUOTE(str)
	#define ZSTD_VERSION_STRING ZSTD_EXPAND_AND_QUOTE(ZSTD_LIB_VERSION)
	ZSTDLIB_API const char* ZSTD_versionString(void); /* requires v1.3.0+ */

	/* *************************************
	* Default constant
	***************************************/
	#ifndef ZSTD_CLEVEL_DEFAULT
	# define ZSTD_CLEVEL_DEFAULT 3
	#endif

	/* *************************************
	* Constants
	***************************************/

	/* All magic numbers are supposed read/written to/from files/memory using little-endian convention */
	#define ZSTD_MAGICNUMBER 0xFD2FB528 /* valid since v0.8.0 */
	#define ZSTD_MAGIC_DICTIONARY 0xEC30A437 /* valid since v0.7.0 */
	#define ZSTD_MAGIC_SKIPPABLE_START 0x184D2A50 /* all 16 values, from 0x184D2A50 to 0x184D2A5F, signal the beginning of a skippable frame */
	#define ZSTD_MAGIC_SKIPPABLE_MASK 0xFFFFFFF0

	#define ZSTD_BLOCKSIZELOG_MAX 17
	#define ZSTD_BLOCKSIZE_MAX (1<<ZSTD_BLOCKSIZELOG_MAX)



	/***************************************
	* Simple API
	***************************************/
	/*! ZSTD_compress() :
	* Compresses `src` content as a single zstd compressed frame into already allocated `dst`.
	* Hint : compression runs faster if `dstCapacity` >= `ZSTD_compressBound(srcSize)`.
	* @return : compressed size written into `dst` (<= `dstCapacity),
	* or an error code if it fails (which can be tested using ZSTD_isError()). */
	ZSTDLIB_API size_t ZSTD_compress( void* dst, size_t dstCapacity,
	const void* src, size_t srcSize,
	int compressionLevel);

	/*! ZSTD_decompress() :
	* `compressedSize` : must be the _exact_ size of some number of compressed and/or skippable frames.
	* `dstCapacity` is an upper bound of originalSize to regenerate.
	* If user cannot imply a maximum upper bound, it's better to use streaming mode to decompress data.
	* @return : the number of bytes decompressed into `dst` (<= `dstCapacity`),
	* or an errorCode if it fails (which can be tested using ZSTD_isError()). */
	ZSTDLIB_API size_t ZSTD_decompress( void* dst, size_t dstCapacity,
	const void* src, size_t compressedSize);

	/*! ZSTD_getFrameContentSize() : requires v1.3.0+
	* `src` should point to the start of a ZSTD encoded frame.
	* `srcSize` must be at least as large as the frame header.
	* hint : any size >= `ZSTD_frameHeaderSize_max` is large enough.
	* @return : - decompressed size of `src` frame content, if known
	* - ZSTD_CONTENTSIZE_UNKNOWN if the size cannot be determined
	* - ZSTD_CONTENTSIZE_ERROR if an error occurred (e.g. invalid magic number, srcSize too small)
	* note 1 : a 0 return value means the frame is valid but "empty".
	* note 2 : decompressed size is an optional field, it may not be present, typically in streaming mode.
	* When `return==ZSTD_CONTENTSIZE_UNKNOWN`, data to decompress could be any size.
	* In which case, it's necessary to use streaming mode to decompress data.
	* Optionally, application can rely on some implicit limit,
	* as ZSTD_decompress() only needs an upper bound of decompressed size.
	* (For example, data could be necessarily cut into blocks <= 16 KB).
	* note 3 : decompressed size is always present when compression is completed using single-pass functions,
	* such as ZSTD_compress(), ZSTD_compressCCtx() ZSTD_compress_usingDict() or ZSTD_compress_usingCDict().
	* note 4 : decompressed size can be very large (64-bits value),
	* potentially larger than what local system can handle as a single memory segment.
	* In which case, it's necessary to use streaming mode to decompress data.
	* note 5 : If source is untrusted, decompressed size could be wrong or intentionally modified.
	* Always ensure return value fits within application's authorized limits.
	* Each application can set its own limits.
	* note 6 : This function replaces ZSTD_getDecompressedSize() */
	#define ZSTD_CONTENTSIZE_UNKNOWN (0ULL - 1)
	#define ZSTD_CONTENTSIZE_ERROR (0ULL - 2)
	ZSTDLIB_API unsigned long long ZSTD_getFrameContentSize(const void *src, size_t srcSize);

	/*! ZSTD_getDecompressedSize() :
	* NOTE: This function is now obsolete, in favor of ZSTD_getFrameContentSize().
	* Both functions work the same way, but ZSTD_getDecompressedSize() blends
	* "empty", "unknown" and "error" results to the same return value (0),
	* while ZSTD_getFrameContentSize() gives them separate return values.
	* @return : decompressed size of `src` frame content _if known and not empty_, 0 otherwise. */
	ZSTDLIB_API unsigned long long ZSTD_getDecompressedSize(const void* src, size_t srcSize);

	/*! ZSTD_findFrameCompressedSize() :
	* `src` should point to the start of a ZSTD frame or skippable frame.
	* `srcSize` must be >= first frame size
	* @return : the compressed size of the first frame starting at `src`,
	* suitable to pass as `srcSize` to `ZSTD_decompress` or similar,
	* or an error code if input is invalid */
	ZSTDLIB_API size_t ZSTD_findFrameCompressedSize(const void* src, size_t srcSize);


	/====== Helper functions ======/
	#define ZSTD_COMPRESSBOUND(srcSize) ((srcSize) + ((srcSize)>>8) + (((srcSize) < (128<<10)) ? (((128<<10) - (srcSize)) >> 11) /* margin, from 64 to 0 / : 0)) / this formula ensures that bound(A) + bound(B) <= bound(A+B) as long as A and B >= 128 KB */
	ZSTDLIB_API size_t ZSTD_compressBound(size_t srcSize); /!< maximum compressed size in worst case single-pass scenario /
	ZSTDLIB_API unsigned ZSTD_isError(size_t code); /!< tells if a `size_t` function result is an error code /
	ZSTDLIB_API const char* ZSTD_getErrorName(size_t code); /!< provides readable string from an error code /
	ZSTDLIB_API int ZSTD_minCLevel(void); /!< minimum negative compression level allowed /
	ZSTDLIB_API int ZSTD_maxCLevel(void); /!< maximum compression level available /


	/***************************************
	* Explicit context
	***************************************/
	/*= Compression context
	* When compressing many times,
	* it is recommended to allocate a context just once,
	* and re-use it for each successive compression operation.
	* This will make workload friendlier for system's memory.
	* Note : re-using context is just a speed / resource optimization.
	* It doesn't change the compression ratio, which remains identical.
	* Note 2 : In multi-threaded environments,
	* use one different context per thread for parallel execution.
	*/
	typedef struct ZSTD_CCtx_s ZSTD_CCtx;
	ZSTDLIB_API ZSTD_CCtx* ZSTD_createCCtx(void);
	ZSTDLIB_API size_t ZSTD_freeCCtx(ZSTD_CCtx* cctx);

	/*! ZSTD_compressCCtx() :
	* Same as ZSTD_compress(), using an explicit ZSTD_CCtx.
	* Important : in order to behave similarly to `ZSTD_compress()`,
	* this function compresses at requested compression level,
	* __ignoring any other parameter__ .
	* If any advanced parameter was set using the advanced API,
	* they will all be reset. Only `compressionLevel` remains.
	*/
	ZSTDLIB_API size_t ZSTD_compressCCtx(ZSTD_CCtx* cctx,
	void* dst, size_t dstCapacity,
	const void* src, size_t srcSize,
	int compressionLevel);

	/*= Decompression context
	* When decompressing many times,
	* it is recommended to allocate a context only once,
	* and re-use it for each successive compression operation.
	* This will make workload friendlier for system's memory.
	* Use one context per thread for parallel execution. */
	typedef struct ZSTD_DCtx_s ZSTD_DCtx;
	ZSTDLIB_API ZSTD_DCtx* ZSTD_createDCtx(void);
	ZSTDLIB_API size_t ZSTD_freeDCtx(ZSTD_DCtx* dctx);

	/*! ZSTD_decompressDCtx() :
	* Same as ZSTD_decompress(),
	* requires an allocated ZSTD_DCtx.
	* Compatible with sticky parameters.
	*/
	ZSTDLIB_API size_t ZSTD_decompressDCtx(ZSTD_DCtx* dctx,
	void* dst, size_t dstCapacity,
	const void* src, size_t srcSize);


	/***************************************
	* Advanced compression API
	***************************************/

	/* API design :
	* Parameters are pushed one by one into an existing context,
	* using ZSTD_CCtx_set*() functions.
	* Pushed parameters are sticky : they are valid for next compressed frame, and any subsequent frame.
	* "sticky" parameters are applicable to `ZSTD_compress2()` and `ZSTD_compressStream*()` !
	* __They do not apply to "simple" one-shot variants such as ZSTD_compressCCtx()__ .
	*
	* It's possible to reset all parameters to "default" using ZSTD_CCtx_reset().
	*
	* This API supercedes all other "advanced" API entry points in the experimental section.
	* In the future, we expect to remove from experimental API entry points which are redundant with this API.
	*/


	/* Compression strategies, listed from fastest to strongest */
	typedef enum { ZSTD_fast=1,
	ZSTD_dfast=2,
	ZSTD_greedy=3,
	ZSTD_lazy=4,
	ZSTD_lazy2=5,
	ZSTD_btlazy2=6,
	ZSTD_btopt=7,
	ZSTD_btultra=8,
	ZSTD_btultra2=9
	/* note : new strategies _might_ be added in the future.
	Only the order (from fast to strong) is guaranteed */
	} ZSTD_strategy;


	typedef enum {

	/* compression parameters
	* Note: When compressing with a ZSTD_CDict these parameters are superseded
	* by the parameters used to construct the ZSTD_CDict.
	* See ZSTD_CCtx_refCDict() for more info (superseded-by-cdict). */
	ZSTD_c_compressionLevel=100, /* Set compression parameters according to pre-defined cLevel table.
	* Note that exact compression parameters are dynamically determined,
	* depending on both compression level and srcSize (when known).
	* Default level is ZSTD_CLEVEL_DEFAULT==3.
	* Special: value 0 means default, which is controlled by ZSTD_CLEVEL_DEFAULT.
	* Note 1 : it's possible to pass a negative compression level.
	* Note 2 : setting a level does not automatically set all other compression parameters
	* to default. Setting this will however eventually dynamically impact the compression
	* parameters which have not been manually set. The manually set
	* ones will 'stick'. */
	/* Advanced compression parameters :
	* It's possible to pin down compression parameters to some specific values.
	* In which case, these values are no longer dynamically selected by the compressor */
	ZSTD_c_windowLog=101, /* Maximum allowed back-reference distance, expressed as power of 2.
	* This will set a memory budget for streaming decompression,
	* with larger values requiring more memory
	* and typically compressing more.
	* Must be clamped between ZSTD_WINDOWLOG_MIN and ZSTD_WINDOWLOG_MAX.
	* Special: value 0 means "use default windowLog".
	* Note: Using a windowLog greater than ZSTD_WINDOWLOG_LIMIT_DEFAULT
	* requires explicitly allowing such size at streaming decompression stage. */
	ZSTD_c_hashLog=102, /* Size of the initial probe table, as a power of 2.
	* Resulting memory usage is (1 << (hashLog+2)).
	* Must be clamped between ZSTD_HASHLOG_MIN and ZSTD_HASHLOG_MAX.
	* Larger tables improve compression ratio of strategies <= dFast,
	* and improve speed of strategies > dFast.
	* Special: value 0 means "use default hashLog". */
	ZSTD_c_chainLog=103, /* Size of the multi-probe search table, as a power of 2.
	* Resulting memory usage is (1 << (chainLog+2)).
	* Must be clamped between ZSTD_CHAINLOG_MIN and ZSTD_CHAINLOG_MAX.
	* Larger tables result in better and slower compression.
	* This parameter is useless for "fast" strategy.
	* It's still useful when using "dfast" strategy,
	* in which case it defines a secondary probe table.
	* Special: value 0 means "use default chainLog". */
	ZSTD_c_searchLog=104, /* Number of search attempts, as a power of 2.
	* More attempts result in better and slower compression.
	* This parameter is useless for "fast" and "dFast" strategies.
	* Special: value 0 means "use default searchLog". */
	ZSTD_c_minMatch=105, /* Minimum size of searched matches.
	* Note that Zstandard can still find matches of smaller size,
	* it just tweaks its search algorithm to look for this size and larger.
	* Larger values increase compression and decompression speed, but decrease ratio.
	* Must be clamped between ZSTD_MINMATCH_MIN and ZSTD_MINMATCH_MAX.
	* Note that currently, for all strategies < btopt, effective minimum is 4.
	* , for all strategies > fast, effective maximum is 6.
	* Special: value 0 means "use default minMatchLength". */
	ZSTD_c_targetLength=106, /* Impact of this field depends on strategy.
	* For strategies btopt, btultra & btultra2:
	* Length of Match considered "good enough" to stop search.
	* Larger values make compression stronger, and slower.
	* For strategy fast:
	* Distance between match sampling.
	* Larger values make compression faster, and weaker.
	* Special: value 0 means "use default targetLength". */
	ZSTD_c_strategy=107, /* See ZSTD_strategy enum definition.
	* The higher the value of selected strategy, the more complex it is,
	* resulting in stronger and slower compression.
	* Special: value 0 means "use default strategy". */

	/* LDM mode parameters */
	ZSTD_c_enableLongDistanceMatching=160, /* Enable long distance matching.
	* This parameter is designed to improve compression ratio
	* for large inputs, by finding large matches at long distance.
	* It increases memory usage and window size.
	* Note: enabling this parameter increases default ZSTD_c_windowLog to 128 MB
	* except when expressly set to a different value. */
	ZSTD_c_ldmHashLog=161, /* Size of the table for long distance matching, as a power of 2.
	* Larger values increase memory usage and compression ratio,
	* but decrease compression speed.
	* Must be clamped between ZSTD_HASHLOG_MIN and ZSTD_HASHLOG_MAX
	* default: windowlog - 7.
	* Special: value 0 means "automatically determine hashlog". */
	ZSTD_c_ldmMinMatch=162, /* Minimum match size for long distance matcher.
	* Larger/too small values usually decrease compression ratio.
	* Must be clamped between ZSTD_LDM_MINMATCH_MIN and ZSTD_LDM_MINMATCH_MAX.
	* Special: value 0 means "use default value" (default: 64). */
	ZSTD_c_ldmBucketSizeLog=163, /* Log size of each bucket in the LDM hash table for collision resolution.
	* Larger values improve collision resolution but decrease compression speed.
	* The maximum value is ZSTD_LDM_BUCKETSIZELOG_MAX.
	* Special: value 0 means "use default value" (default: 3). */
	ZSTD_c_ldmHashRateLog=164, /* Frequency of inserting/looking up entries into the LDM hash table.
	* Must be clamped between 0 and (ZSTD_WINDOWLOG_MAX - ZSTD_HASHLOG_MIN).
	* Default is MAX(0, (windowLog - ldmHashLog)), optimizing hash table usage.
	* Larger values improve compression speed.
	* Deviating far from default value will likely result in a compression ratio decrease.
	* Special: value 0 means "automatically determine hashRateLog". */

	/* frame parameters */
	ZSTD_c_contentSizeFlag=200, /* Content size will be written into frame header _whenever known_ (default:1)
	* Content size must be known at the beginning of compression.
	* This is automatically the case when using ZSTD_compress2(),
	* For streaming scenarios, content size must be provided with ZSTD_CCtx_setPledgedSrcSize() */
	ZSTD_c_checksumFlag=201, /* A 32-bits checksum of content is written at end of frame (default:0) */
	ZSTD_c_dictIDFlag=202, /* When applicable, dictionary's ID is written into frame header (default:1) */

	/* multi-threading parameters */
	/* These parameters are only useful if multi-threading is enabled (compiled with build macro ZSTD_MULTITHREAD).
	* They return an error otherwise. */
	ZSTD_c_nbWorkers=400, /* Select how many threads will be spawned to compress in parallel.
	* When nbWorkers >= 1, triggers asynchronous mode when used with ZSTD_compressStream*() :
	* ZSTD_compressStream*() consumes input and flush output if possible, but immediately gives back control to caller,
	* while compression work is performed in parallel, within worker threads.
	* (note : a strong exception to this rule is when first invocation of ZSTD_compressStream2() sets ZSTD_e_end :
	* in which case, ZSTD_compressStream2() delegates to ZSTD_compress2(), which is always a blocking call).
	* More workers improve speed, but also increase memory usage.
	* Default value is `0`, aka "single-threaded mode" : no worker is spawned, compression is performed inside Caller's thread, all invocations are blocking */
	ZSTD_c_jobSize=401, /* Size of a compression job. This value is enforced only when nbWorkers >= 1.
	* Each compression job is completed in parallel, so this value can indirectly impact the nb of active threads.
	* 0 means default, which is dynamically determined based on compression parameters.
	* Job size must be a minimum of overlap size, or 1 MB, whichever is largest.
	* The minimum size is automatically and transparently enforced. */
	ZSTD_c_overlapLog=402, /* Control the overlap size, as a fraction of window size.
	* The overlap size is an amount of data reloaded from previous job at the beginning of a new job.
	* It helps preserve compression ratio, while each job is compressed in parallel.
	* This value is enforced only when nbWorkers >= 1.
	* Larger values increase compression ratio, but decrease speed.
	* Possible values range from 0 to 9 :
	* - 0 means "default" : value will be determined by the library, depending on strategy
	* - 1 means "no overlap"
	* - 9 means "full overlap", using a full window size.
	* Each intermediate rank increases/decreases load size by a factor 2 :
	* 9: full window; 8: w/2; 7: w/4; 6: w/8; 5:w/16; 4: w/32; 3:w/64; 2:w/128; 1:no overlap; 0:default
	* default value varies between 6 and 9, depending on strategy */

	/* note : additional experimental parameters are also available
	* within the experimental section of the API.
	* At the time of this writing, they include :
	* ZSTD_c_rsyncable
	* ZSTD_c_format
	* ZSTD_c_forceMaxWindow
	* ZSTD_c_forceAttachDict
	* ZSTD_c_literalCompressionMode
	* ZSTD_c_targetCBlockSize
	* ZSTD_c_srcSizeHint
	* Because they are not stable, it's necessary to define ZSTD_STATIC_LINKING_ONLY to access them.
	* note : never ever use experimentalParam? names directly;
	* also, the enums values themselves are unstable and can still change.
	*/
	ZSTD_c_experimentalParam1=500,
	ZSTD_c_experimentalParam2=10,
	ZSTD_c_experimentalParam3=1000,
	ZSTD_c_experimentalParam4=1001,
	ZSTD_c_experimentalParam5=1002,
	ZSTD_c_experimentalParam6=1003,
	ZSTD_c_experimentalParam7=1004
	} ZSTD_cParameter;

	typedef struct {
	size_t error;
	int lowerBound;
	int upperBound;
	} ZSTD_bounds;

	/*! ZSTD_cParam_getBounds() :
	* All parameters must belong to an interval with lower and upper bounds,
	* otherwise they will either trigger an error or be automatically clamped.
	* @return : a structure, ZSTD_bounds, which contains
	* - an error status field, which must be tested using ZSTD_isError()
	* - lower and upper bounds, both inclusive
	*/
	ZSTDLIB_API ZSTD_bounds ZSTD_cParam_getBounds(ZSTD_cParameter cParam);

	/*! ZSTD_CCtx_setParameter() :
	* Set one compression parameter, selected by enum ZSTD_cParameter.
	* All parameters have valid bounds. Bounds can be queried using ZSTD_cParam_getBounds().
	* Providing a value beyond bound will either clamp it, or trigger an error (depending on parameter).
	* Setting a parameter is generally only possible during frame initialization (before starting compression).
	* Exception : when using multi-threading mode (nbWorkers >= 1),
	* the following parameters can be updated _during_ compression (within same frame):
	* => compressionLevel, hashLog, chainLog, searchLog, minMatch, targetLength and strategy.
	* new parameters will be active for next job only (after a flush()).
	* @return : an error code (which can be tested using ZSTD_isError()).
	*/
	ZSTDLIB_API size_t ZSTD_CCtx_setParameter(ZSTD_CCtx* cctx, ZSTD_cParameter param, int value);

	/*! ZSTD_CCtx_setPledgedSrcSize() :
	* Total input data size to be compressed as a single frame.
	* Value will be written in frame header, unless if explicitly forbidden using ZSTD_c_contentSizeFlag.
	* This value will also be controlled at end of frame, and trigger an error if not respected.
	* @result : 0, or an error code (which can be tested with ZSTD_isError()).
	* Note 1 : pledgedSrcSize==0 actually means zero, aka an empty frame.
	* In order to mean "unknown content size", pass constant ZSTD_CONTENTSIZE_UNKNOWN.
	* ZSTD_CONTENTSIZE_UNKNOWN is default value for any new frame.
	* Note 2 : pledgedSrcSize is only valid once, for the next frame.
	* It's discarded at the end of the frame, and replaced by ZSTD_CONTENTSIZE_UNKNOWN.
	* Note 3 : Whenever all input data is provided and consumed in a single round,
	* for example with ZSTD_compress2(),
	* or invoking immediately ZSTD_compressStream2(,,,ZSTD_e_end),
	* this value is automatically overridden by srcSize instead.
	*/
	ZSTDLIB_API size_t ZSTD_CCtx_setPledgedSrcSize(ZSTD_CCtx* cctx, unsigned long long pledgedSrcSize);

	typedef enum {
	ZSTD_reset_session_only = 1,
	ZSTD_reset_parameters = 2,
	ZSTD_reset_session_and_parameters = 3
	} ZSTD_ResetDirective;

	/*! ZSTD_CCtx_reset() :
	* There are 2 different things that can be reset, independently or jointly :
	* - The session : will stop compressing current frame, and make CCtx ready to start a new one.
	* Useful after an error, or to interrupt any ongoing compression.
	* Any internal data not yet flushed is cancelled.
	* Compression parameters and dictionary remain unchanged.
	* They will be used to compress next frame.
	* Resetting session never fails.
	* - The parameters : changes all parameters back to "default".
	* This removes any reference to any dictionary too.
	* Parameters can only be changed between 2 sessions (i.e. no compression is currently ongoing)
	* otherwise the reset fails, and function returns an error value (which can be tested using ZSTD_isError())
	* - Both : similar to resetting the session, followed by resetting parameters.
	*/
	ZSTDLIB_API size_t ZSTD_CCtx_reset(ZSTD_CCtx* cctx, ZSTD_ResetDirective reset);

	/*! ZSTD_compress2() :
	* Behave the same as ZSTD_compressCCtx(), but compression parameters are set using the advanced API.
	* ZSTD_compress2() always starts a new frame.
	* Should cctx hold data from a previously unfinished frame, everything about it is forgotten.
	* - Compression parameters are pushed into CCtx before starting compression, using ZSTD_CCtx_set*()
	* - The function is always blocking, returns when compression is completed.
	* Hint : compression runs faster if `dstCapacity` >= `ZSTD_compressBound(srcSize)`.
	* @return : compressed size written into `dst` (<= `dstCapacity),
	* or an error code if it fails (which can be tested using ZSTD_isError()).
	*/
	ZSTDLIB_API size_t ZSTD_compress2( ZSTD_CCtx* cctx,
	void* dst, size_t dstCapacity,
	const void* src, size_t srcSize);


	/***************************************
	* Advanced decompression API
	***************************************/

	/* The advanced API pushes parameters one by one into an existing DCtx context.
	* Parameters are sticky, and remain valid for all following frames
	* using the same DCtx context.
	* It's possible to reset parameters to default values using ZSTD_DCtx_reset().
	* Note : This API is compatible with existing ZSTD_decompressDCtx() and ZSTD_decompressStream().
	* Therefore, no new decompression function is necessary.
	*/

	typedef enum {

	ZSTD_d_windowLogMax=100, /* Select a size limit (in power of 2) beyond which
	* the streaming API will refuse to allocate memory buffer
	* in order to protect the host from unreasonable memory requirements.
	* This parameter is only useful in streaming mode, since no internal buffer is allocated in single-pass mode.
	* By default, a decompression context accepts window sizes <= (1 << ZSTD_WINDOWLOG_LIMIT_DEFAULT).
	* Special: value 0 means "use default maximum windowLog". */

	/* note : additional experimental parameters are also available
	* within the experimental section of the API.
	* At the time of this writing, they include :
	* ZSTD_d_format
	* ZSTD_d_stableOutBuffer
	* Because they are not stable, it's necessary to define ZSTD_STATIC_LINKING_ONLY to access them.
	* note : never ever use experimentalParam? names directly
	*/
	ZSTD_d_experimentalParam1=1000,
	ZSTD_d_experimentalParam2=1001

	} ZSTD_dParameter;

	/*! ZSTD_dParam_getBounds() :
	* All parameters must belong to an interval with lower and upper bounds,
	* otherwise they will either trigger an error or be automatically clamped.
	* @return : a structure, ZSTD_bounds, which contains
	* - an error status field, which must be tested using ZSTD_isError()
	* - both lower and upper bounds, inclusive
	*/
	ZSTDLIB_API ZSTD_bounds ZSTD_dParam_getBounds(ZSTD_dParameter dParam);

	/*! ZSTD_DCtx_setParameter() :
	* Set one compression parameter, selected by enum ZSTD_dParameter.
	* All parameters have valid bounds. Bounds can be queried using ZSTD_dParam_getBounds().
	* Providing a value beyond bound will either clamp it, or trigger an error (depending on parameter).
	* Setting a parameter is only possible during frame initialization (before starting decompression).
	* @return : 0, or an error code (which can be tested using ZSTD_isError()).
	*/
	ZSTDLIB_API size_t ZSTD_DCtx_setParameter(ZSTD_DCtx* dctx, ZSTD_dParameter param, int value);

	/*! ZSTD_DCtx_reset() :
	* Return a DCtx to clean state.
	* Session and parameters can be reset jointly or separately.
	* Parameters can only be reset when no active frame is being decompressed.
	* @return : 0, or an error code, which can be tested with ZSTD_isError()
	*/
	ZSTDLIB_API size_t ZSTD_DCtx_reset(ZSTD_DCtx* dctx, ZSTD_ResetDirective reset);


	/****************************
	* Streaming
	****************************/

	typedef struct ZSTD_inBuffer_s {
	const void* src; /*< start of input buffer /
	size_t size; /*< size of input buffer /
	size_t pos; /*< position where reading stopped. Will be updated. Necessarily 0 <= pos <= size /
	} ZSTD_inBuffer;

	typedef struct ZSTD_outBuffer_s {
	void* dst; /*< start of output buffer /
	size_t size; /*< size of output buffer /
	size_t pos; /*< position where writing stopped. Will be updated. Necessarily 0 <= pos <= size /
	} ZSTD_outBuffer;



	/-**********************************************************************
	* Streaming compression - HowTo
	*
	* A ZSTD_CStream object is required to track streaming operation.
	* Use ZSTD_createCStream() and ZSTD_freeCStream() to create/release resources.
	* ZSTD_CStream objects can be reused multiple times on consecutive compression operations.
	* It is recommended to re-use ZSTD_CStream since it will play nicer with system's memory, by re-using already allocated memory.
	*
	* For parallel execution, use one separate ZSTD_CStream per thread.
	*
	* note : since v1.3.0, ZSTD_CStream and ZSTD_CCtx are the same thing.
	*
	* Parameters are sticky : when starting a new compression on the same context,
	* it will re-use the same sticky parameters as previous compression session.
	* When in doubt, it's recommended to fully initialize the context before usage.
	* Use ZSTD_CCtx_reset() to reset the context and ZSTD_CCtx_setParameter(),
	* ZSTD_CCtx_setPledgedSrcSize(), or ZSTD_CCtx_loadDictionary() and friends to
	* set more specific parameters, the pledged source size, or load a dictionary.
	*
	* Use ZSTD_compressStream2() with ZSTD_e_continue as many times as necessary to
	* consume input stream. The function will automatically update both `pos`
	* fields within `input` and `output`.
	* Note that the function may not consume the entire input, for example, because
	* the output buffer is already full, in which case `input.pos < input.size`.
	* The caller must check if input has been entirely consumed.
	* If not, the caller must make some room to receive more compressed data,
	* and then present again remaining input data.
	* note: ZSTD_e_continue is guaranteed to make some forward progress when called,
	* but doesn't guarantee maximal forward progress. This is especially relevant
	* when compressing with multiple threads. The call won't block if it can
	* consume some input, but if it can't it will wait for some, but not all,
	* output to be flushed.
	* @return : provides a minimum amount of data remaining to be flushed from internal buffers
	* or an error code, which can be tested using ZSTD_isError().
	*
	* At any moment, it's possible to flush whatever data might remain stuck within internal buffer,
	* using ZSTD_compressStream2() with ZSTD_e_flush. `output->pos` will be updated.
	* Note that, if `output->size` is too small, a single invocation with ZSTD_e_flush might not be enough (return code > 0).
	* In which case, make some room to receive more compressed data, and call again ZSTD_compressStream2() with ZSTD_e_flush.
	* You must continue calling ZSTD_compressStream2() with ZSTD_e_flush until it returns 0, at which point you can change the
	* operation.
	* note: ZSTD_e_flush will flush as much output as possible, meaning when compressing with multiple threads, it will
	* block until the flush is complete or the output buffer is full.
	* @return : 0 if internal buffers are entirely flushed,
	* >0 if some data still present within internal buffer (the value is minimal estimation of remaining size),
	* or an error code, which can be tested using ZSTD_isError().
	*
	* Calling ZSTD_compressStream2() with ZSTD_e_end instructs to finish a frame.
	* It will perform a flush and write frame epilogue.
	* The epilogue is required for decoders to consider a frame completed.
	* flush operation is the same, and follows same rules as calling ZSTD_compressStream2() with ZSTD_e_flush.
	* You must continue calling ZSTD_compressStream2() with ZSTD_e_end until it returns 0, at which point you are free to
	* start a new frame.
	* note: ZSTD_e_end will flush as much output as possible, meaning when compressing with multiple threads, it will
	* block until the flush is complete or the output buffer is full.
	* @return : 0 if frame fully completed and fully flushed,
	* >0 if some data still present within internal buffer (the value is minimal estimation of remaining size),
	* or an error code, which can be tested using ZSTD_isError().
	*
	* *******************************************************************/

	typedef ZSTD_CCtx ZSTD_CStream; /*< CCtx and CStream are now effectively same object (>= v1.3.0) /
	/* Continue to distinguish them for compatibility with older versions <= v1.2.0 */
	/===== ZSTD_CStream management functions =====/
	ZSTDLIB_API ZSTD_CStream* ZSTD_createCStream(void);
	ZSTDLIB_API size_t ZSTD_freeCStream(ZSTD_CStream* zcs);

	/===== Streaming compression functions =====/
	typedef enum {
	ZSTD_e_continue=0, /* collect more data, encoder decides when to output compressed result, for optimal compression ratio */
	ZSTD_e_flush=1, /* flush any data provided so far,
	* it creates (at least) one new block, that can be decoded immediately on reception;
	* frame will continue: any future data can still reference previously compressed data, improving compression.
	* note : multithreaded compression will block to flush as much output as possible. */
	ZSTD_e_end=2 /* flush any remaining data _and_ close current frame.
	* note that frame is only closed after compressed data is fully flushed (return value == 0).
	* After that point, any additional data starts a new frame.
	* note : each frame is independent (does not reference any content from previous frame).
	: note : multithreaded compression will block to flush as much output as possible. */
	} ZSTD_EndDirective;

	/*! ZSTD_compressStream2() :
	* Behaves about the same as ZSTD_compressStream, with additional control on end directive.
	* - Compression parameters are pushed into CCtx before starting compression, using ZSTD_CCtx_set*()
	* - Compression parameters cannot be changed once compression is started (save a list of exceptions in multi-threading mode)
	* - output->pos must be <= dstCapacity, input->pos must be <= srcSize
	* - output->pos and input->pos will be updated. They are guaranteed to remain below their respective limit.
	* - When nbWorkers==0 (default), function is blocking : it completes its job before returning to caller.
	* - When nbWorkers>=1, function is non-blocking : it just acquires a copy of input, and distributes jobs to internal worker threads, flush whatever is available,
	* and then immediately returns, just indicating that there is some data remaining to be flushed.
	* The function nonetheless guarantees forward progress : it will return only after it reads or write at least 1+ byte.
	* - Exception : if the first call requests a ZSTD_e_end directive and provides enough dstCapacity, the function delegates to ZSTD_compress2() which is always blocking.
	* - @return provides a minimum amount of data remaining to be flushed from internal buffers
	* or an error code, which can be tested using ZSTD_isError().
	* if @return != 0, flush is not fully completed, there is still some data left within internal buffers.
	* This is useful for ZSTD_e_flush, since in this case more flushes are necessary to empty all buffers.
	* For ZSTD_e_end, @return == 0 when internal buffers are fully flushed and frame is completed.
	* - after a ZSTD_e_end directive, if internal buffer is not fully flushed (@return != 0),
	* only ZSTD_e_end or ZSTD_e_flush operations are allowed.
	* Before starting a new compression job, or changing compression parameters,
	* it is required to fully flush internal buffers.
	*/
	ZSTDLIB_API size_t ZSTD_compressStream2( ZSTD_CCtx* cctx,
	ZSTD_outBuffer* output,
	ZSTD_inBuffer* input,
	ZSTD_EndDirective endOp);


	/* These buffer sizes are softly recommended.
	* They are not required : ZSTD_compressStream*() happily accepts any buffer size, for both input and output.
	* Respecting the recommended size just makes it a bit easier for ZSTD_compressStream*(),
	* reducing the amount of memory shuffling and buffering, resulting in minor performance savings.
	*
	* However, note that these recommendations are from the perspective of a C caller program.
	* If the streaming interface is invoked from some other language,
	* especially managed ones such as Java or Go, through a foreign function interface such as jni or cgo,
	* a major performance rule is to reduce crossing such interface to an absolute minimum.
	* It's not rare that performance ends being spent more into the interface, rather than compression itself.
	* In which cases, prefer using large buffers, as large as practical,
	* for both input and output, to reduce the nb of roundtrips.
	*/
	ZSTDLIB_API size_t ZSTD_CStreamInSize(void); /*< recommended size for input buffer /
	ZSTDLIB_API size_t ZSTD_CStreamOutSize(void); /*< recommended size for output buffer. Guarantee to successfully flush at least one complete compressed block. /


	/* *****************************************************************************
	* This following is a legacy streaming API.
	* It can be replaced by ZSTD_CCtx_reset() and ZSTD_compressStream2().
	* It is redundant, but remains fully supported.
	* Advanced parameters and dictionary compression can only be used through the
	* new API.
	******************************************************************************/

	/*!
	* Equivalent to:
	*
	* ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);
	* ZSTD_CCtx_refCDict(zcs, NULL); // clear the dictionary (if any)
	* ZSTD_CCtx_setParameter(zcs, ZSTD_c_compressionLevel, compressionLevel);
	*/
	ZSTDLIB_API size_t ZSTD_initCStream(ZSTD_CStream* zcs, int compressionLevel);
	/*!
	* Alternative for ZSTD_compressStream2(zcs, output, input, ZSTD_e_continue).
	* NOTE: The return value is different. ZSTD_compressStream() returns a hint for
	* the next read size (if non-zero and not an error). ZSTD_compressStream2()
	* returns the minimum nb of bytes left to flush (if non-zero and not an error).
	*/
	ZSTDLIB_API size_t ZSTD_compressStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output, ZSTD_inBuffer* input);
	/! Equivalent to ZSTD_compressStream2(zcs, output, &emptyInput, ZSTD_e_flush). /
	ZSTDLIB_API size_t ZSTD_flushStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output);
	/! Equivalent to ZSTD_compressStream2(zcs, output, &emptyInput, ZSTD_e_end). /
	ZSTDLIB_API size_t ZSTD_endStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output);


	/-**************************************************************************
	* Streaming decompression - HowTo
	*
	* A ZSTD_DStream object is required to track streaming operations.
	* Use ZSTD_createDStream() and ZSTD_freeDStream() to create/release resources.
	* ZSTD_DStream objects can be re-used multiple times.
	*
	* Use ZSTD_initDStream() to start a new decompression operation.
	* @return : recommended first input size
	* Alternatively, use advanced API to set specific properties.
	*
	* Use ZSTD_decompressStream() repetitively to consume your input.
	* The function will update both `pos` fields.
	* If `input.pos < input.size`, some input has not been consumed.
	* It's up to the caller to present again remaining data.
	* The function tries to flush all data decoded immediately, respecting output buffer size.
	* If `output.pos < output.size`, decoder has flushed everything it could.
	* But if `output.pos == output.size`, there might be some data left within internal buffers.,
	* In which case, call ZSTD_decompressStream() again to flush whatever remains in the buffer.
	* Note : with no additional input provided, amount of data flushed is necessarily <= ZSTD_BLOCKSIZE_MAX.
	* @return : 0 when a frame is completely decoded and fully flushed,
	* or an error code, which can be tested using ZSTD_isError(),
	* or any other value > 0, which means there is still some decoding or flushing to do to complete current frame :
	* the return value is a suggested next input size (just a hint for better latency)
	* that will never request more than the remaining frame size.
	* *******************************************************************************/

	typedef ZSTD_DCtx ZSTD_DStream; /*< DCtx and DStream are now effectively same object (>= v1.3.0) /
	/* For compatibility with versions <= v1.2.0, prefer differentiating them. */
	/===== ZSTD_DStream management functions =====/
	ZSTDLIB_API ZSTD_DStream* ZSTD_createDStream(void);
	ZSTDLIB_API size_t ZSTD_freeDStream(ZSTD_DStream* zds);

	/===== Streaming decompression functions =====/

	/* This function is redundant with the advanced API and equivalent to:
	*
	* ZSTD_DCtx_reset(zds, ZSTD_reset_session_only);
	* ZSTD_DCtx_refDDict(zds, NULL);
	*/
	ZSTDLIB_API size_t ZSTD_initDStream(ZSTD_DStream* zds);

	ZSTDLIB_API size_t ZSTD_decompressStream(ZSTD_DStream* zds, ZSTD_outBuffer* output, ZSTD_inBuffer* input);

	ZSTDLIB_API size_t ZSTD_DStreamInSize(void); /!< recommended size for input buffer /
	ZSTDLIB_API size_t ZSTD_DStreamOutSize(void); /!< recommended size for output buffer. Guarantee to successfully flush at least one complete block in all circumstances. /


	/**************************
	* Simple dictionary API
	***************************/
	/*! ZSTD_compress_usingDict() :
	* Compression at an explicit compression level using a Dictionary.
	* A dictionary can be any arbitrary data segment (also called a prefix),
	* or a buffer with specified information (see dictBuilder/zdict.h).
	* Note : This function loads the dictionary, resulting in significant startup delay.
	* It's intended for a dictionary used only once.
	* Note 2 : When `dict == NULL \|\| dictSize < 8` no dictionary is used. */
	ZSTDLIB_API size_t ZSTD_compress_usingDict(ZSTD_CCtx* ctx,
	void* dst, size_t dstCapacity,
	const void* src, size_t srcSize,
	const void* dict,size_t dictSize,
	int compressionLevel);

	/*! ZSTD_decompress_usingDict() :
	* Decompression using a known Dictionary.
	* Dictionary must be identical to the one used during compression.
	* Note : This function loads the dictionary, resulting in significant startup delay.
	* It's intended for a dictionary used only once.
	* Note : When `dict == NULL \|\| dictSize < 8` no dictionary is used. */
	ZSTDLIB_API size_t ZSTD_decompress_usingDict(ZSTD_DCtx* dctx,
	void* dst, size_t dstCapacity,
	const void* src, size_t srcSize,
	const void* dict,size_t dictSize);


	/***********************************
	* Bulk processing dictionary API
	**********************************/
	typedef struct ZSTD_CDict_s ZSTD_CDict;

	/*! ZSTD_createCDict() :
	* When compressing multiple messages or blocks using the same dictionary,
	* it's recommended to digest the dictionary only once, since it's a costly operation.
	* ZSTD_createCDict() will create a state from digesting a dictionary.
	* The resulting state can be used for future compression operations with very limited startup cost.
	* ZSTD_CDict can be created once and shared by multiple threads concurrently, since its usage is read-only.
	* @dictBuffer can be released after ZSTD_CDict creation, because its content is copied within CDict.
	* Note 1 : Consider experimental function `ZSTD_createCDict_byReference()` if you prefer to not duplicate @dictBuffer content.
	* Note 2 : A ZSTD_CDict can be created from an empty @dictBuffer,
	* in which case the only thing that it transports is the @compressionLevel.
	* This can be useful in a pipeline featuring ZSTD_compress_usingCDict() exclusively,
	* expecting a ZSTD_CDict parameter with any data, including those without a known dictionary. */
	ZSTDLIB_API ZSTD_CDict* ZSTD_createCDict(const void* dictBuffer, size_t dictSize,
	int compressionLevel);

	/*! ZSTD_freeCDict() :
	* Function frees memory allocated by ZSTD_createCDict(). */
	ZSTDLIB_API size_t ZSTD_freeCDict(ZSTD_CDict* CDict);

	/*! ZSTD_compress_usingCDict() :
	* Compression using a digested Dictionary.
	* Recommended when same dictionary is used multiple times.
	* Note : compression level is _decided at dictionary creation time_,
	* and frame parameters are hardcoded (dictID=yes, contentSize=yes, checksum=no) */
	ZSTDLIB_API size_t ZSTD_compress_usingCDict(ZSTD_CCtx* cctx,
	void* dst, size_t dstCapacity,
	const void* src, size_t srcSize,
	const ZSTD_CDict* cdict);


	typedef struct ZSTD_DDict_s ZSTD_DDict;

	/*! ZSTD_createDDict() :
	* Create a digested dictionary, ready to start decompression operation without startup delay.
	* dictBuffer can be released after DDict creation, as its content is copied inside DDict. */
	ZSTDLIB_API ZSTD_DDict* ZSTD_createDDict(const void* dictBuffer, size_t dictSize);

	/*! ZSTD_freeDDict() :
	* Function frees memory allocated with ZSTD_createDDict() */
	ZSTDLIB_API size_t ZSTD_freeDDict(ZSTD_DDict* ddict);

	/*! ZSTD_decompress_usingDDict() :
	* Decompression using a digested Dictionary.
	* Recommended when same dictionary is used multiple times. */
	ZSTDLIB_API size_t ZSTD_decompress_usingDDict(ZSTD_DCtx* dctx,
	void* dst, size_t dstCapacity,
	const void* src, size_t srcSize,
	const ZSTD_DDict* ddict);


	/********************************
	* Dictionary helper functions
	*******************************/

	/*! ZSTD_getDictID_fromDict() :
	* Provides the dictID stored within dictionary.
	* if @return == 0, the dictionary is not conformant with Zstandard specification.
	* It can still be loaded, but as a content-only dictionary. */
	ZSTDLIB_API unsigned ZSTD_getDictID_fromDict(const void* dict, size_t dictSize);

	/*! ZSTD_getDictID_fromDDict() :
	* Provides the dictID of the dictionary loaded into `ddict`.
	* If @return == 0, the dictionary is not conformant to Zstandard specification, or empty.
	* Non-conformant dictionaries can still be loaded, but as content-only dictionaries. */
	ZSTDLIB_API unsigned ZSTD_getDictID_fromDDict(const ZSTD_DDict* ddict);

	/*! ZSTD_getDictID_fromFrame() :
	* Provides the dictID required to decompressed the frame stored within `src`.
	* If @return == 0, the dictID could not be decoded.
	* This could for one of the following reasons :
	* - The frame does not require a dictionary to be decoded (most common case).
	* - The frame was built with dictID intentionally removed. Whatever dictionary is necessary is a hidden information.
	* Note : this use case also happens when using a non-conformant dictionary.
	* - `srcSize` is too small, and as a result, the frame header could not be decoded (only possible if `srcSize < ZSTD_FRAMEHEADERSIZE_MAX`).
	* - This is not a Zstandard frame.
	* When identifying the exact failure cause, it's possible to use ZSTD_getFrameHeader(), which will provide a more precise error code. */
	ZSTDLIB_API unsigned ZSTD_getDictID_fromFrame(const void* src, size_t srcSize);


	/*******************************************************************************
	* Advanced dictionary and prefix API
	*
	* This API allows dictionaries to be used with ZSTD_compress2(),
	* ZSTD_compressStream2(), and ZSTD_decompress(). Dictionaries are sticky, and
	* only reset with the context is reset with ZSTD_reset_parameters or
	* ZSTD_reset_session_and_parameters. Prefixes are single-use.
	******************************************************************************/


	/*! ZSTD_CCtx_loadDictionary() :
	* Create an internal CDict from `dict` buffer.
	* Decompression will have to use same dictionary.
	* @result : 0, or an error code (which can be tested with ZSTD_isError()).
	* Special: Loading a NULL (or 0-size) dictionary invalidates previous dictionary,
	* meaning "return to no-dictionary mode".
	* Note 1 : Dictionary is sticky, it will be used for all future compressed frames.
	* To return to "no-dictionary" situation, load a NULL dictionary (or reset parameters).
	* Note 2 : Loading a dictionary involves building tables.
	* It's also a CPU consuming operation, with non-negligible impact on latency.
	* Tables are dependent on compression parameters, and for this reason,
	* compression parameters can no longer be changed after loading a dictionary.
	* Note 3 :`dict` content will be copied internally.
	* Use experimental ZSTD_CCtx_loadDictionary_byReference() to reference content instead.
	* In such a case, dictionary buffer must outlive its users.
	* Note 4 : Use ZSTD_CCtx_loadDictionary_advanced()
	* to precisely select how dictionary content must be interpreted. */
	ZSTDLIB_API size_t ZSTD_CCtx_loadDictionary(ZSTD_CCtx* cctx, const void* dict, size_t dictSize);

	/*! ZSTD_CCtx_refCDict() :
	* Reference a prepared dictionary, to be used for all next compressed frames.
	* Note that compression parameters are enforced from within CDict,
	* and supersede any compression parameter previously set within CCtx.
	* The parameters ignored are labled as "superseded-by-cdict" in the ZSTD_cParameter enum docs.
	* The ignored parameters will be used again if the CCtx is returned to no-dictionary mode.
	* The dictionary will remain valid for future compressed frames using same CCtx.
	* @result : 0, or an error code (which can be tested with ZSTD_isError()).
	* Special : Referencing a NULL CDict means "return to no-dictionary mode".
	* Note 1 : Currently, only one dictionary can be managed.
	* Referencing a new dictionary effectively "discards" any previous one.
	* Note 2 : CDict is just referenced, its lifetime must outlive its usage within CCtx. */
	ZSTDLIB_API size_t ZSTD_CCtx_refCDict(ZSTD_CCtx* cctx, const ZSTD_CDict* cdict);

	/*! ZSTD_CCtx_refPrefix() :
	* Reference a prefix (single-usage dictionary) for next compressed frame.
	* A prefix is only used once. Tables are discarded at end of frame (ZSTD_e_end).
	* Decompression will need same prefix to properly regenerate data.
	* Compressing with a prefix is similar in outcome as performing a diff and compressing it,
	* but performs much faster, especially during decompression (compression speed is tunable with compression level).
	* @result : 0, or an error code (which can be tested with ZSTD_isError()).
	* Special: Adding any prefix (including NULL) invalidates any previous prefix or dictionary
	* Note 1 : Prefix buffer is referenced. It must outlive compression.
	* Its content must remain unmodified during compression.
	* Note 2 : If the intention is to diff some large src data blob with some prior version of itself,
	* ensure that the window size is large enough to contain the entire source.
	* See ZSTD_c_windowLog.
	* Note 3 : Referencing a prefix involves building tables, which are dependent on compression parameters.
	* It's a CPU consuming operation, with non-negligible impact on latency.
	* If there is a need to use the same prefix multiple times, consider loadDictionary instead.
	* Note 4 : By default, the prefix is interpreted as raw content (ZSTD_dct_rawContent).
	* Use experimental ZSTD_CCtx_refPrefix_advanced() to alter dictionary interpretation. */
	ZSTDLIB_API size_t ZSTD_CCtx_refPrefix(ZSTD_CCtx* cctx,
	const void* prefix, size_t prefixSize);

	/*! ZSTD_DCtx_loadDictionary() :
	* Create an internal DDict from dict buffer,
	* to be used to decompress next frames.
	* The dictionary remains valid for all future frames, until explicitly invalidated.
	* @result : 0, or an error code (which can be tested with ZSTD_isError()).
	* Special : Adding a NULL (or 0-size) dictionary invalidates any previous dictionary,
	* meaning "return to no-dictionary mode".
	* Note 1 : Loading a dictionary involves building tables,
	* which has a non-negligible impact on CPU usage and latency.
	* It's recommended to "load once, use many times", to amortize the cost
	* Note 2 :`dict` content will be copied internally, so `dict` can be released after loading.
	* Use ZSTD_DCtx_loadDictionary_byReference() to reference dictionary content instead.
	* Note 3 : Use ZSTD_DCtx_loadDictionary_advanced() to take control of
	* how dictionary content is loaded and interpreted.
	*/
	ZSTDLIB_API size_t ZSTD_DCtx_loadDictionary(ZSTD_DCtx* dctx, const void* dict, size_t dictSize);

	/*! ZSTD_DCtx_refDDict() :
	* Reference a prepared dictionary, to be used to decompress next frames.
	* The dictionary remains active for decompression of future frames using same DCtx.
	* @result : 0, or an error code (which can be tested with ZSTD_isError()).
	* Note 1 : Currently, only one dictionary can be managed.
	* Referencing a new dictionary effectively "discards" any previous one.
	* Special: referencing a NULL DDict means "return to no-dictionary mode".
	* Note 2 : DDict is just referenced, its lifetime must outlive its usage from DCtx.
	*/
	ZSTDLIB_API size_t ZSTD_DCtx_refDDict(ZSTD_DCtx* dctx, const ZSTD_DDict* ddict);

	/*! ZSTD_DCtx_refPrefix() :
	* Reference a prefix (single-usage dictionary) to decompress next frame.
	* This is the reverse operation of ZSTD_CCtx_refPrefix(),
	* and must use the same prefix as the one used during compression.
	* Prefix is only used once. Reference is discarded at end of frame.
	* End of frame is reached when ZSTD_decompressStream() returns 0.
	* @result : 0, or an error code (which can be tested with ZSTD_isError()).
	* Note 1 : Adding any prefix (including NULL) invalidates any previously set prefix or dictionary
	* Note 2 : Prefix buffer is referenced. It must outlive decompression.
	* Prefix buffer must remain unmodified up to the end of frame,
	* reached when ZSTD_decompressStream() returns 0.
	* Note 3 : By default, the prefix is treated as raw content (ZSTD_dct_rawContent).
	* Use ZSTD_CCtx_refPrefix_advanced() to alter dictMode (Experimental section)
	* Note 4 : Referencing a raw content prefix has almost no cpu nor memory cost.
	* A full dictionary is more costly, as it requires building tables.
	*/
	ZSTDLIB_API size_t ZSTD_DCtx_refPrefix(ZSTD_DCtx* dctx,
	const void* prefix, size_t prefixSize);

	/* === Memory management === */

	/! ZSTD_sizeof_() :
	* These functions give the _current_ memory usage of selected object.
	* Note that object memory usage can evolve (increase or decrease) over time. */
	ZSTDLIB_API size_t ZSTD_sizeof_CCtx(const ZSTD_CCtx* cctx);
	ZSTDLIB_API size_t ZSTD_sizeof_DCtx(const ZSTD_DCtx* dctx);
	ZSTDLIB_API size_t ZSTD_sizeof_CStream(const ZSTD_CStream* zcs);
	ZSTDLIB_API size_t ZSTD_sizeof_DStream(const ZSTD_DStream* zds);
	ZSTDLIB_API size_t ZSTD_sizeof_CDict(const ZSTD_CDict* cdict);
	ZSTDLIB_API size_t ZSTD_sizeof_DDict(const ZSTD_DDict* ddict);

	#endif /* ZSTD_H_235446 */


	/* **************************************************************************************
	* ADVANCED AND EXPERIMENTAL FUNCTIONS
	****************************************************************************************
	* The definitions in the following section are considered experimental.
	* They are provided for advanced scenarios.
	* They should never be used with a dynamic library, as prototypes may change in the future.
	* Use them only in association with static linking.
	* ***************************************************************************************/

	#if defined(ZSTD_STATIC_LINKING_ONLY) && !defined(ZSTD_H_ZSTD_STATIC_LINKING_ONLY)
	#define ZSTD_H_ZSTD_STATIC_LINKING_ONLY

	/****************************************************************************************
	* experimental API (static linking only)
	****************************************************************************************
	* The following symbols and constants
	* are not planned to join "stable API" status in the near future.
	* They can still change in future versions.
	* Some of them are planned to remain in the static_only section indefinitely.
	* Some of them might be removed in the future (especially when redundant with existing stable functions)
	* ***************************************************************************************/

	#define ZSTD_FRAMEHEADERSIZE_PREFIX(format) ((format) == ZSTD_f_zstd1 ? 5 : 1) /* minimum input size required to query frame header size */
	#define ZSTD_FRAMEHEADERSIZE_MIN(format) ((format) == ZSTD_f_zstd1 ? 6 : 2)
	#define ZSTD_FRAMEHEADERSIZE_MAX 18 /* can be useful for static allocation */
	#define ZSTD_SKIPPABLEHEADERSIZE 8

	/* compression parameter bounds */
	#define ZSTD_WINDOWLOG_MAX_32 30
	#define ZSTD_WINDOWLOG_MAX_64 31
	#define ZSTD_WINDOWLOG_MAX ((int)(sizeof(size_t) == 4 ? ZSTD_WINDOWLOG_MAX_32 : ZSTD_WINDOWLOG_MAX_64))
	#define ZSTD_WINDOWLOG_MIN 10
	#define ZSTD_HASHLOG_MAX ((ZSTD_WINDOWLOG_MAX < 30) ? ZSTD_WINDOWLOG_MAX : 30)
	#define ZSTD_HASHLOG_MIN 6
	#define ZSTD_CHAINLOG_MAX_32 29
	#define ZSTD_CHAINLOG_MAX_64 30
	#define ZSTD_CHAINLOG_MAX ((int)(sizeof(size_t) == 4 ? ZSTD_CHAINLOG_MAX_32 : ZSTD_CHAINLOG_MAX_64))
	#define ZSTD_CHAINLOG_MIN ZSTD_HASHLOG_MIN
	#define ZSTD_SEARCHLOG_MAX (ZSTD_WINDOWLOG_MAX-1)
	#define ZSTD_SEARCHLOG_MIN 1
	#define ZSTD_MINMATCH_MAX 7 /* only for ZSTD_fast, other strategies are limited to 6 */
	#define ZSTD_MINMATCH_MIN 3 /* only for ZSTD_btopt+, faster strategies are limited to 4 */
	#define ZSTD_TARGETLENGTH_MAX ZSTD_BLOCKSIZE_MAX
	#define ZSTD_TARGETLENGTH_MIN 0 /* note : comparing this constant to an unsigned results in a tautological test */
	#define ZSTD_STRATEGY_MIN ZSTD_fast
	#define ZSTD_STRATEGY_MAX ZSTD_btultra2


	#define ZSTD_OVERLAPLOG_MIN 0
	#define ZSTD_OVERLAPLOG_MAX 9

	#define ZSTD_WINDOWLOG_LIMIT_DEFAULT 27 /* by default, the streaming decoder will refuse any frame
	* requiring larger than (1<<ZSTD_WINDOWLOG_LIMIT_DEFAULT) window size,
	* to preserve host's memory from unreasonable requirements.
	* This limit can be overridden using ZSTD_DCtx_setParameter(,ZSTD_d_windowLogMax,).
	* The limit does not apply for one-pass decoders (such as ZSTD_decompress()), since no additional memory is allocated */


	/* LDM parameter bounds */
	#define ZSTD_LDM_HASHLOG_MIN ZSTD_HASHLOG_MIN
	#define ZSTD_LDM_HASHLOG_MAX ZSTD_HASHLOG_MAX
	#define ZSTD_LDM_MINMATCH_MIN 4
	#define ZSTD_LDM_MINMATCH_MAX 4096
	#define ZSTD_LDM_BUCKETSIZELOG_MIN 1
	#define ZSTD_LDM_BUCKETSIZELOG_MAX 8
	#define ZSTD_LDM_HASHRATELOG_MIN 0
	#define ZSTD_LDM_HASHRATELOG_MAX (ZSTD_WINDOWLOG_MAX - ZSTD_HASHLOG_MIN)

	/* Advanced parameter bounds */
	#define ZSTD_TARGETCBLOCKSIZE_MIN 64
	#define ZSTD_TARGETCBLOCKSIZE_MAX ZSTD_BLOCKSIZE_MAX
	#define ZSTD_SRCSIZEHINT_MIN 0
	#define ZSTD_SRCSIZEHINT_MAX INT_MAX

	/* internal */
	#define ZSTD_HASHLOG3_MAX 17


	/* --- Advanced types --- */

	typedef struct ZSTD_CCtx_params_s ZSTD_CCtx_params;

	typedef struct {
	unsigned int matchPos; /* Match pos in dst */
	/* If seqDef.offset > 3, then this is seqDef.offset - 3
	* If seqDef.offset < 3, then this is the corresponding repeat offset
	* But if seqDef.offset < 3 and litLength == 0, this is the
	* repeat offset before the corresponding repeat offset
	* And if seqDef.offset == 3 and litLength == 0, this is the
	* most recent repeat offset - 1
	*/
	unsigned int offset;
	unsigned int litLength; /* Literal length */
	unsigned int matchLength; /* Match length */
	/* 0 when seq not rep and seqDef.offset otherwise
	* when litLength == 0 this will be <= 4, otherwise <= 3 like normal
	*/
	unsigned int rep;
	} ZSTD_Sequence;

	typedef struct {
	unsigned windowLog; /*< largest match distance : larger == more compression, more memory needed during decompression /
	unsigned chainLog; /*< fully searched segment : larger == more compression, slower, more memory (useless for fast) /
	unsigned hashLog; /*< dispatch table : larger == faster, more memory /
	unsigned searchLog; /*< nb of searches : larger == more compression, slower /
	unsigned minMatch; /*< match length searched : larger == faster decompression, sometimes less compression /
	unsigned targetLength; /*< acceptable match size for optimal parser (only) : larger == more compression, slower /
	ZSTD_strategy strategy; /*< see ZSTD_strategy definition above /
	} ZSTD_compressionParameters;

	typedef struct {
	int contentSizeFlag; /*< 1: content size will be in frame header (when known) /
	int checksumFlag; /*< 1: generate a 32-bits checksum using XXH64 algorithm at end of frame, for error detection /
	int noDictIDFlag; /*< 1: no dictID will be saved into frame header (dictID is only useful for dictionary compression) /
	} ZSTD_frameParameters;

	typedef struct {
	ZSTD_compressionParameters cParams;
	ZSTD_frameParameters fParams;
	} ZSTD_parameters;

	typedef enum {
	ZSTD_dct_auto = 0, /* dictionary is "full" when starting with ZSTD_MAGIC_DICTIONARY, otherwise it is "rawContent" */
	ZSTD_dct_rawContent = 1, /* ensures dictionary is always loaded as rawContent, even if it starts with ZSTD_MAGIC_DICTIONARY */
	ZSTD_dct_fullDict = 2 /* refuses to load a dictionary if it does not respect Zstandard's specification, starting with ZSTD_MAGIC_DICTIONARY */
	} ZSTD_dictContentType_e;

	typedef enum {
	ZSTD_dlm_byCopy = 0, /*< Copy dictionary content internally /
	ZSTD_dlm_byRef = 1 /*< Reference dictionary content -- the dictionary buffer must outlive its users. /
	} ZSTD_dictLoadMethod_e;

	typedef enum {
	ZSTD_f_zstd1 = 0, /* zstd frame format, specified in zstd_compression_format.md (default) */
	ZSTD_f_zstd1_magicless = 1 /* Variant of zstd frame format, without initial 4-bytes magic number.
	* Useful to save 4 bytes per generated frame.
	* Decoder cannot recognise automatically this format, requiring this instruction. */
	} ZSTD_format_e;

	typedef enum {
	/* Note: this enum and the behavior it controls are effectively internal
	* implementation details of the compressor. They are expected to continue
	* to evolve and should be considered only in the context of extremely
	* advanced performance tuning.
	*
	* Zstd currently supports the use of a CDict in three ways:
	*
	* - The contents of the CDict can be copied into the working context. This
	* means that the compression can search both the dictionary and input
	* while operating on a single set of internal tables. This makes
	* the compression faster per-byte of input. However, the initial copy of
	* the CDict's tables incurs a fixed cost at the beginning of the
	* compression. For small compressions (< 8 KB), that copy can dominate
	* the cost of the compression.
	*
	* - The CDict's tables can be used in-place. In this model, compression is
	* slower per input byte, because the compressor has to search two sets of
	* tables. However, this model incurs no start-up cost (as long as the
	* working context's tables can be reused). For small inputs, this can be
	* faster than copying the CDict's tables.
	*
	* - The CDict's tables are not used at all, and instead we use the working
	* context alone to reload the dictionary and use params based on the source
	* size. See ZSTD_compress_insertDictionary() and ZSTD_compress_usingDict().
	* This method is effective when the dictionary sizes are very small relative
	* to the input size, and the input size is fairly large to begin with.
	*
	* Zstd has a simple internal heuristic that selects which strategy to use
	* at the beginning of a compression. However, if experimentation shows that
	* Zstd is making poor choices, it is possible to override that choice with
	* this enum.
	*/
	ZSTD_dictDefaultAttach = 0, /* Use the default heuristic. */
	ZSTD_dictForceAttach = 1, /* Never copy the dictionary. */
	ZSTD_dictForceCopy = 2, /* Always copy the dictionary. */
	ZSTD_dictForceLoad = 3 /* Always reload the dictionary */
	} ZSTD_dictAttachPref_e;

	typedef enum {
	ZSTD_lcm_auto = 0, /**< Automatically determine the compression mode based on the compression level.
	* Negative compression levels will be uncompressed, and positive compression
	* levels will be compressed. */
	ZSTD_lcm_huffman = 1, /**< Always attempt Huffman compression. Uncompressed literals will still be
	* emitted if Huffman compression is not profitable. */
	ZSTD_lcm_uncompressed = 2 /*< Always emit uncompressed literals. /
	} ZSTD_literalCompressionMode_e;


	/***************************************
	* Frame size functions
	***************************************/

	/*! ZSTD_findDecompressedSize() :
	* `src` should point to the start of a series of ZSTD encoded and/or skippable frames
	* `srcSize` must be the _exact_ size of this series
	* (i.e. there should be a frame boundary at `src + srcSize`)
	* @return : - decompressed size of all data in all successive frames
	* - if the decompressed size cannot be determined: ZSTD_CONTENTSIZE_UNKNOWN
	* - if an error occurred: ZSTD_CONTENTSIZE_ERROR
	*
	* note 1 : decompressed size is an optional field, that may not be present, especially in streaming mode.
	* When `return==ZSTD_CONTENTSIZE_UNKNOWN`, data to decompress could be any size.
	* In which case, it's necessary to use streaming mode to decompress data.
	* note 2 : decompressed size is always present when compression is done with ZSTD_compress()
	* note 3 : decompressed size can be very large (64-bits value),
	* potentially larger than what local system can handle as a single memory segment.
	* In which case, it's necessary to use streaming mode to decompress data.
	* note 4 : If source is untrusted, decompressed size could be wrong or intentionally modified.
	* Always ensure result fits within application's authorized limits.
	* Each application can set its own limits.
	* note 5 : ZSTD_findDecompressedSize handles multiple frames, and so it must traverse the input to
	* read each contained frame header. This is fast as most of the data is skipped,
	* however it does mean that all frame data must be present and valid. */
	ZSTDLIB_API unsigned long long ZSTD_findDecompressedSize(const void* src, size_t srcSize);

	/*! ZSTD_decompressBound() :
	* `src` should point to the start of a series of ZSTD encoded and/or skippable frames
	* `srcSize` must be the _exact_ size of this series
	* (i.e. there should be a frame boundary at `src + srcSize`)
	* @return : - upper-bound for the decompressed size of all data in all successive frames
	* - if an error occured: ZSTD_CONTENTSIZE_ERROR
	*
	* note 1 : an error can occur if `src` contains an invalid or incorrectly formatted frame.
	* note 2 : the upper-bound is exact when the decompressed size field is available in every ZSTD encoded frame of `src`.
	* in this case, `ZSTD_findDecompressedSize` and `ZSTD_decompressBound` return the same value.
	* note 3 : when the decompressed size field isn't available, the upper-bound for that frame is calculated by:
	* upper-bound = # blocks * min(128 KB, Window_Size)
	*/
	ZSTDLIB_API unsigned long long ZSTD_decompressBound(const void* src, size_t srcSize);

	/*! ZSTD_frameHeaderSize() :
	* srcSize must be >= ZSTD_FRAMEHEADERSIZE_PREFIX.
	* @return : size of the Frame Header,
	* or an error code (if srcSize is too small) */
	ZSTDLIB_API size_t ZSTD_frameHeaderSize(const void* src, size_t srcSize);

	/*! ZSTD_getSequences() :
	* Extract sequences from the sequence store
	* zc can be used to insert custom compression params.
	* This function invokes ZSTD_compress2
	* @return : number of sequences extracted
	*/
	ZSTDLIB_API size_t ZSTD_getSequences(ZSTD_CCtx* zc, ZSTD_Sequence* outSeqs,
	size_t outSeqsSize, const void* src, size_t srcSize);


	/***************************************
	* Memory management
	***************************************/

	/! ZSTD_estimate() :
	* These functions make it possible to estimate memory usage
	* of a future {D,C}Ctx, before its creation.
	*
	* ZSTD_estimateCCtxSize() will provide a memory budget large enough
	* for any compression level up to selected one.
	* Note : Unlike ZSTD_estimateCStreamSize*(), this estimate
	* does not include space for a window buffer.
	* Therefore, the estimation is only guaranteed for single-shot compressions, not streaming.
	* The estimate will assume the input may be arbitrarily large,
	* which is the worst case.
	*
	* When srcSize can be bound by a known and rather "small" value,
	* this fact can be used to provide a tighter estimation
	* because the CCtx compression context will need less memory.
	* This tighter estimation can be provided by more advanced functions
	* ZSTD_estimateCCtxSize_usingCParams(), which can be used in tandem with ZSTD_getCParams(),
	* and ZSTD_estimateCCtxSize_usingCCtxParams(), which can be used in tandem with ZSTD_CCtxParams_setParameter().
	* Both can be used to estimate memory using custom compression parameters and arbitrary srcSize limits.
	*
	* Note 2 : only single-threaded compression is supported.
	* ZSTD_estimateCCtxSize_usingCCtxParams() will return an error code if ZSTD_c_nbWorkers is >= 1.
	*/
	ZSTDLIB_API size_t ZSTD_estimateCCtxSize(int compressionLevel);
	ZSTDLIB_API size_t ZSTD_estimateCCtxSize_usingCParams(ZSTD_compressionParameters cParams);
	ZSTDLIB_API size_t ZSTD_estimateCCtxSize_usingCCtxParams(const ZSTD_CCtx_params* params);
	ZSTDLIB_API size_t ZSTD_estimateDCtxSize(void);

	/*! ZSTD_estimateCStreamSize() :
	* ZSTD_estimateCStreamSize() will provide a budget large enough for any compression level up to selected one.
	* It will also consider src size to be arbitrarily "large", which is worst case.
	* If srcSize is known to always be small, ZSTD_estimateCStreamSize_usingCParams() can provide a tighter estimation.
	* ZSTD_estimateCStreamSize_usingCParams() can be used in tandem with ZSTD_getCParams() to create cParams from compressionLevel.
	* ZSTD_estimateCStreamSize_usingCCtxParams() can be used in tandem with ZSTD_CCtxParams_setParameter(). Only single-threaded compression is supported. This function will return an error code if ZSTD_c_nbWorkers is >= 1.
	* Note : CStream size estimation is only correct for single-threaded compression.
	* ZSTD_DStream memory budget depends on window Size.
	* This information can be passed manually, using ZSTD_estimateDStreamSize,
	* or deducted from a valid frame Header, using ZSTD_estimateDStreamSize_fromFrame();
	* Note : if streaming is init with function ZSTD_init?Stream_usingDict(),
	* an internal ?Dict will be created, which additional size is not estimated here.
	* In this case, get total size by adding ZSTD_estimate?DictSize */
	ZSTDLIB_API size_t ZSTD_estimateCStreamSize(int compressionLevel);
	ZSTDLIB_API size_t ZSTD_estimateCStreamSize_usingCParams(ZSTD_compressionParameters cParams);
	ZSTDLIB_API size_t ZSTD_estimateCStreamSize_usingCCtxParams(const ZSTD_CCtx_params* params);
	ZSTDLIB_API size_t ZSTD_estimateDStreamSize(size_t windowSize);
	ZSTDLIB_API size_t ZSTD_estimateDStreamSize_fromFrame(const void* src, size_t srcSize);

	/*! ZSTD_estimate?DictSize() :
	* ZSTD_estimateCDictSize() will bet that src size is relatively "small", and content is copied, like ZSTD_createCDict().
	* ZSTD_estimateCDictSize_advanced() makes it possible to control compression parameters precisely, like ZSTD_createCDict_advanced().
	* Note : dictionaries created by reference (`ZSTD_dlm_byRef`) are logically smaller.
	*/
	ZSTDLIB_API size_t ZSTD_estimateCDictSize(size_t dictSize, int compressionLevel);
	ZSTDLIB_API size_t ZSTD_estimateCDictSize_advanced(size_t dictSize, ZSTD_compressionParameters cParams, ZSTD_dictLoadMethod_e dictLoadMethod);
	ZSTDLIB_API size_t ZSTD_estimateDDictSize(size_t dictSize, ZSTD_dictLoadMethod_e dictLoadMethod);

	/! ZSTD_initStatic() :
	* Initialize an object using a pre-allocated fixed-size buffer.
	* workspace: The memory area to emplace the object into.
	* Provided pointer must be 8-bytes aligned.
	* Buffer must outlive object.
	* workspaceSize: Use ZSTD_estimate*Size() to determine
	* how large workspace must be to support target scenario.
	* @return : pointer to object (same address as workspace, just different type),
	* or NULL if error (size too small, incorrect alignment, etc.)
	* Note : zstd will never resize nor malloc() when using a static buffer.
	* If the object requires more memory than available,
	* zstd will just error out (typically ZSTD_error_memory_allocation).
	* Note 2 : there is no corresponding "free" function.
	* Since workspace is allocated externally, it must be freed externally too.
	* Note 3 : cParams : use ZSTD_getCParams() to convert a compression level
	* into its associated cParams.
	* Limitation 1 : currently not compatible with internal dictionary creation, triggered by
	* ZSTD_CCtx_loadDictionary(), ZSTD_initCStream_usingDict() or ZSTD_initDStream_usingDict().
	* Limitation 2 : static cctx currently not compatible with multi-threading.
	* Limitation 3 : static dctx is incompatible with legacy support.
	*/
	ZSTDLIB_API ZSTD_CCtx* ZSTD_initStaticCCtx(void* workspace, size_t workspaceSize);
	ZSTDLIB_API ZSTD_CStream* ZSTD_initStaticCStream(void* workspace, size_t workspaceSize); /*< same as ZSTD_initStaticCCtx() /

	ZSTDLIB_API ZSTD_DCtx* ZSTD_initStaticDCtx(void* workspace, size_t workspaceSize);
	ZSTDLIB_API ZSTD_DStream* ZSTD_initStaticDStream(void* workspace, size_t workspaceSize); /*< same as ZSTD_initStaticDCtx() /

	ZSTDLIB_API const ZSTD_CDict* ZSTD_initStaticCDict(
	void* workspace, size_t workspaceSize,
	const void* dict, size_t dictSize,
	ZSTD_dictLoadMethod_e dictLoadMethod,
	ZSTD_dictContentType_e dictContentType,
	ZSTD_compressionParameters cParams);

	ZSTDLIB_API const ZSTD_DDict* ZSTD_initStaticDDict(
	void* workspace, size_t workspaceSize,
	const void* dict, size_t dictSize,
	ZSTD_dictLoadMethod_e dictLoadMethod,
	ZSTD_dictContentType_e dictContentType);


	/*! Custom memory allocation :
	* These prototypes make it possible to pass your own allocation/free functions.
	* ZSTD_customMem is provided at creation time, using ZSTD_create*_advanced() variants listed below.
	* All allocation/free operations will be completed using these custom variants instead of regular <stdlib.h> ones.
	*/
	typedef void* (ZSTD_allocFunction) (void opaque, size_t size);
	typedef void (ZSTD_freeFunction) (void opaque, void* address);
	typedef struct { ZSTD_allocFunction customAlloc; ZSTD_freeFunction customFree; void* opaque; } ZSTD_customMem;
	static ZSTD_customMem const ZSTD_defaultCMem = { NULL, NULL, NULL }; /*< this constant defers to stdlib's functions /

	ZSTDLIB_API ZSTD_CCtx* ZSTD_createCCtx_advanced(ZSTD_customMem customMem);
	ZSTDLIB_API ZSTD_CStream* ZSTD_createCStream_advanced(ZSTD_customMem customMem);
	ZSTDLIB_API ZSTD_DCtx* ZSTD_createDCtx_advanced(ZSTD_customMem customMem);
	ZSTDLIB_API ZSTD_DStream* ZSTD_createDStream_advanced(ZSTD_customMem customMem);

	ZSTDLIB_API ZSTD_CDict* ZSTD_createCDict_advanced(const void* dict, size_t dictSize,
	ZSTD_dictLoadMethod_e dictLoadMethod,
	ZSTD_dictContentType_e dictContentType,
	ZSTD_compressionParameters cParams,
	ZSTD_customMem customMem);

	ZSTDLIB_API ZSTD_DDict* ZSTD_createDDict_advanced(const void* dict, size_t dictSize,
	ZSTD_dictLoadMethod_e dictLoadMethod,
	ZSTD_dictContentType_e dictContentType,
	ZSTD_customMem customMem);



	/***************************************
	* Advanced compression functions
	***************************************/

	/*! ZSTD_createCDict_byReference() :
	* Create a digested dictionary for compression
	* Dictionary content is just referenced, not duplicated.
	* As a consequence, `dictBuffer` must outlive CDict,
	* and its content must remain unmodified throughout the lifetime of CDict.
	* note: equivalent to ZSTD_createCDict_advanced(), with dictLoadMethod==ZSTD_dlm_byRef */
	ZSTDLIB_API ZSTD_CDict* ZSTD_createCDict_byReference(const void* dictBuffer, size_t dictSize, int compressionLevel);

	/*! ZSTD_getCParams() :
	* @return ZSTD_compressionParameters structure for a selected compression level and estimated srcSize.
	* `estimatedSrcSize` value is optional, select 0 if not known */
	ZSTDLIB_API ZSTD_compressionParameters ZSTD_getCParams(int compressionLevel, unsigned long long estimatedSrcSize, size_t dictSize);

	/*! ZSTD_getParams() :
	* same as ZSTD_getCParams(), but @return a full `ZSTD_parameters` object instead of sub-component `ZSTD_compressionParameters`.
	* All fields of `ZSTD_frameParameters` are set to default : contentSize=1, checksum=0, noDictID=0 */
	ZSTDLIB_API ZSTD_parameters ZSTD_getParams(int compressionLevel, unsigned long long estimatedSrcSize, size_t dictSize);

	/*! ZSTD_checkCParams() :
	* Ensure param values remain within authorized range.
	* @return 0 on success, or an error code (can be checked with ZSTD_isError()) */
	ZSTDLIB_API size_t ZSTD_checkCParams(ZSTD_compressionParameters params);

	/*! ZSTD_adjustCParams() :
	* optimize params for a given `srcSize` and `dictSize`.
	* `srcSize` can be unknown, in which case use ZSTD_CONTENTSIZE_UNKNOWN.
	* `dictSize` must be `0` when there is no dictionary.
	* cPar can be invalid : all parameters will be clamped within valid range in the @return struct.
	* This function never fails (wide contract) */
	ZSTDLIB_API ZSTD_compressionParameters ZSTD_adjustCParams(ZSTD_compressionParameters cPar, unsigned long long srcSize, size_t dictSize);

	/*! ZSTD_compress_advanced() :
	* Note : this function is now DEPRECATED.
	* It can be replaced by ZSTD_compress2(), in combination with ZSTD_CCtx_setParameter() and other parameter setters.
	* This prototype will be marked as deprecated and generate compilation warning on reaching v1.5.x */
	ZSTDLIB_API size_t ZSTD_compress_advanced(ZSTD_CCtx* cctx,
	void* dst, size_t dstCapacity,
	const void* src, size_t srcSize,
	const void* dict,size_t dictSize,
	ZSTD_parameters params);

	/*! ZSTD_compress_usingCDict_advanced() :
	* Note : this function is now REDUNDANT.
	* It can be replaced by ZSTD_compress2(), in combination with ZSTD_CCtx_loadDictionary() and other parameter setters.
	* This prototype will be marked as deprecated and generate compilation warning in some future version */
	ZSTDLIB_API size_t ZSTD_compress_usingCDict_advanced(ZSTD_CCtx* cctx,
	void* dst, size_t dstCapacity,
	const void* src, size_t srcSize,
	const ZSTD_CDict* cdict,
	ZSTD_frameParameters fParams);


	/*! ZSTD_CCtx_loadDictionary_byReference() :
	* Same as ZSTD_CCtx_loadDictionary(), but dictionary content is referenced, instead of being copied into CCtx.
	* It saves some memory, but also requires that `dict` outlives its usage within `cctx` */
	ZSTDLIB_API size_t ZSTD_CCtx_loadDictionary_byReference(ZSTD_CCtx* cctx, const void* dict, size_t dictSize);

	/*! ZSTD_CCtx_loadDictionary_advanced() :
	* Same as ZSTD_CCtx_loadDictionary(), but gives finer control over
	* how to load the dictionary (by copy ? by reference ?)
	* and how to interpret it (automatic ? force raw mode ? full mode only ?) */
	ZSTDLIB_API size_t ZSTD_CCtx_loadDictionary_advanced(ZSTD_CCtx* cctx, const void* dict, size_t dictSize, ZSTD_dictLoadMethod_e dictLoadMethod, ZSTD_dictContentType_e dictContentType);

	/*! ZSTD_CCtx_refPrefix_advanced() :
	* Same as ZSTD_CCtx_refPrefix(), but gives finer control over
	* how to interpret prefix content (automatic ? force raw mode (default) ? full mode only ?) */
	ZSTDLIB_API size_t ZSTD_CCtx_refPrefix_advanced(ZSTD_CCtx* cctx, const void* prefix, size_t prefixSize, ZSTD_dictContentType_e dictContentType);

	/* === experimental parameters === */
	/* these parameters can be used with ZSTD_setParameter()
	* they are not guaranteed to remain supported in the future */

	/* Enables rsyncable mode,
	* which makes compressed files more rsync friendly
	* by adding periodic synchronization points to the compressed data.
	* The target average block size is ZSTD_c_jobSize / 2.
	* It's possible to modify the job size to increase or decrease
	* the granularity of the synchronization point.
	* Once the jobSize is smaller than the window size,
	* it will result in compression ratio degradation.
	* NOTE 1: rsyncable mode only works when multithreading is enabled.
	* NOTE 2: rsyncable performs poorly in combination with long range mode,
	* since it will decrease the effectiveness of synchronization points,
	* though mileage may vary.
	* NOTE 3: Rsyncable mode limits maximum compression speed to ~400 MB/s.
	* If the selected compression level is already running significantly slower,
	* the overall speed won't be significantly impacted.
	*/
	#define ZSTD_c_rsyncable ZSTD_c_experimentalParam1

	/* Select a compression format.
	* The value must be of type ZSTD_format_e.
	* See ZSTD_format_e enum definition for details */
	#define ZSTD_c_format ZSTD_c_experimentalParam2

	/* Force back-reference distances to remain < windowSize,
	* even when referencing into Dictionary content (default:0) */
	#define ZSTD_c_forceMaxWindow ZSTD_c_experimentalParam3

	/* Controls whether the contents of a CDict
	* are used in place, or copied into the working context.
	* Accepts values from the ZSTD_dictAttachPref_e enum.
	* See the comments on that enum for an explanation of the feature. */
	#define ZSTD_c_forceAttachDict ZSTD_c_experimentalParam4

	/* Controls how the literals are compressed (default is auto).
	* The value must be of type ZSTD_literalCompressionMode_e.
	* See ZSTD_literalCompressionMode_t enum definition for details.
	*/
	#define ZSTD_c_literalCompressionMode ZSTD_c_experimentalParam5

	/* Tries to fit compressed block size to be around targetCBlockSize.
	* No target when targetCBlockSize == 0.
	* There is no guarantee on compressed block size (default:0) */
	#define ZSTD_c_targetCBlockSize ZSTD_c_experimentalParam6

	/* User's best guess of source size.
	* Hint is not valid when srcSizeHint == 0.
	* There is no guarantee that hint is close to actual source size,
	* but compression ratio may regress significantly if guess considerably underestimates */
	#define ZSTD_c_srcSizeHint ZSTD_c_experimentalParam7

	/*! ZSTD_CCtx_getParameter() :
	* Get the requested compression parameter value, selected by enum ZSTD_cParameter,
	* and store it into int* value.
	* @return : 0, or an error code (which can be tested with ZSTD_isError()).
	*/
	ZSTDLIB_API size_t ZSTD_CCtx_getParameter(ZSTD_CCtx* cctx, ZSTD_cParameter param, int* value);


	/*! ZSTD_CCtx_params :
	* Quick howto :
	* - ZSTD_createCCtxParams() : Create a ZSTD_CCtx_params structure
	* - ZSTD_CCtxParams_setParameter() : Push parameters one by one into
	* an existing ZSTD_CCtx_params structure.
	* This is similar to
	* ZSTD_CCtx_setParameter().
	* - ZSTD_CCtx_setParametersUsingCCtxParams() : Apply parameters to
	* an existing CCtx.
	* These parameters will be applied to
	* all subsequent frames.
	* - ZSTD_compressStream2() : Do compression using the CCtx.
	* - ZSTD_freeCCtxParams() : Free the memory.
	*
	* This can be used with ZSTD_estimateCCtxSize_advanced_usingCCtxParams()
	* for static allocation of CCtx for single-threaded compression.
	*/
	ZSTDLIB_API ZSTD_CCtx_params* ZSTD_createCCtxParams(void);
	ZSTDLIB_API size_t ZSTD_freeCCtxParams(ZSTD_CCtx_params* params);

	/*! ZSTD_CCtxParams_reset() :
	* Reset params to default values.
	*/
	ZSTDLIB_API size_t ZSTD_CCtxParams_reset(ZSTD_CCtx_params* params);

	/*! ZSTD_CCtxParams_init() :
	* Initializes the compression parameters of cctxParams according to
	* compression level. All other parameters are reset to their default values.
	*/
	ZSTDLIB_API size_t ZSTD_CCtxParams_init(ZSTD_CCtx_params* cctxParams, int compressionLevel);

	/*! ZSTD_CCtxParams_init_advanced() :
	* Initializes the compression and frame parameters of cctxParams according to
	* params. All other parameters are reset to their default values.
	*/
	ZSTDLIB_API size_t ZSTD_CCtxParams_init_advanced(ZSTD_CCtx_params* cctxParams, ZSTD_parameters params);

	/*! ZSTD_CCtxParams_setParameter() :
	* Similar to ZSTD_CCtx_setParameter.
	* Set one compression parameter, selected by enum ZSTD_cParameter.
	* Parameters must be applied to a ZSTD_CCtx using ZSTD_CCtx_setParametersUsingCCtxParams().
	* @result : 0, or an error code (which can be tested with ZSTD_isError()).
	*/
	ZSTDLIB_API size_t ZSTD_CCtxParams_setParameter(ZSTD_CCtx_params* params, ZSTD_cParameter param, int value);

	/*! ZSTD_CCtxParams_getParameter() :
	* Similar to ZSTD_CCtx_getParameter.
	* Get the requested value of one compression parameter, selected by enum ZSTD_cParameter.
	* @result : 0, or an error code (which can be tested with ZSTD_isError()).
	*/
	ZSTDLIB_API size_t ZSTD_CCtxParams_getParameter(ZSTD_CCtx_params* params, ZSTD_cParameter param, int* value);

	/*! ZSTD_CCtx_setParametersUsingCCtxParams() :
	* Apply a set of ZSTD_CCtx_params to the compression context.
	* This can be done even after compression is started,
	* if nbWorkers==0, this will have no impact until a new compression is started.
	* if nbWorkers>=1, new parameters will be picked up at next job,
	* with a few restrictions (windowLog, pledgedSrcSize, nbWorkers, jobSize, and overlapLog are not updated).
	*/
	ZSTDLIB_API size_t ZSTD_CCtx_setParametersUsingCCtxParams(
	ZSTD_CCtx* cctx, const ZSTD_CCtx_params* params);

	/*! ZSTD_compressStream2_simpleArgs() :
	* Same as ZSTD_compressStream2(),
	* but using only integral types as arguments.
	* This variant might be helpful for binders from dynamic languages
	* which have troubles handling structures containing memory pointers.
	*/
	ZSTDLIB_API size_t ZSTD_compressStream2_simpleArgs (
	ZSTD_CCtx* cctx,
	void* dst, size_t dstCapacity, size_t* dstPos,
	const void* src, size_t srcSize, size_t* srcPos,
	ZSTD_EndDirective endOp);


	/***************************************
	* Advanced decompression functions
	***************************************/

	/*! ZSTD_isFrame() :
	* Tells if the content of `buffer` starts with a valid Frame Identifier.
	* Note : Frame Identifier is 4 bytes. If `size < 4`, @return will always be 0.
	* Note 2 : Legacy Frame Identifiers are considered valid only if Legacy Support is enabled.
	* Note 3 : Skippable Frame Identifiers are considered valid. */
	ZSTDLIB_API unsigned ZSTD_isFrame(const void* buffer, size_t size);

	/*! ZSTD_createDDict_byReference() :
	* Create a digested dictionary, ready to start decompression operation without startup delay.
	* Dictionary content is referenced, and therefore stays in dictBuffer.
	* It is important that dictBuffer outlives DDict,
	* it must remain read accessible throughout the lifetime of DDict */
	ZSTDLIB_API ZSTD_DDict* ZSTD_createDDict_byReference(const void* dictBuffer, size_t dictSize);

	/*! ZSTD_DCtx_loadDictionary_byReference() :
	* Same as ZSTD_DCtx_loadDictionary(),
	* but references `dict` content instead of copying it into `dctx`.
	* This saves memory if `dict` remains around.,
	* However, it's imperative that `dict` remains accessible (and unmodified) while being used, so it must outlive decompression. */
	ZSTDLIB_API size_t ZSTD_DCtx_loadDictionary_byReference(ZSTD_DCtx* dctx, const void* dict, size_t dictSize);

	/*! ZSTD_DCtx_loadDictionary_advanced() :
	* Same as ZSTD_DCtx_loadDictionary(),
	* but gives direct control over
	* how to load the dictionary (by copy ? by reference ?)
	* and how to interpret it (automatic ? force raw mode ? full mode only ?). */
	ZSTDLIB_API size_t ZSTD_DCtx_loadDictionary_advanced(ZSTD_DCtx* dctx, const void* dict, size_t dictSize, ZSTD_dictLoadMethod_e dictLoadMethod, ZSTD_dictContentType_e dictContentType);

	/*! ZSTD_DCtx_refPrefix_advanced() :
	* Same as ZSTD_DCtx_refPrefix(), but gives finer control over
	* how to interpret prefix content (automatic ? force raw mode (default) ? full mode only ?) */
	ZSTDLIB_API size_t ZSTD_DCtx_refPrefix_advanced(ZSTD_DCtx* dctx, const void* prefix, size_t prefixSize, ZSTD_dictContentType_e dictContentType);

	/*! ZSTD_DCtx_setMaxWindowSize() :
	* Refuses allocating internal buffers for frames requiring a window size larger than provided limit.
	* This protects a decoder context from reserving too much memory for itself (potential attack scenario).
	* This parameter is only useful in streaming mode, since no internal buffer is allocated in single-pass mode.
	* By default, a decompression context accepts all window sizes <= (1 << ZSTD_WINDOWLOG_LIMIT_DEFAULT)
	* @return : 0, or an error code (which can be tested using ZSTD_isError()).
	*/
	ZSTDLIB_API size_t ZSTD_DCtx_setMaxWindowSize(ZSTD_DCtx* dctx, size_t maxWindowSize);

	/* ZSTD_d_format
	* experimental parameter,
	* allowing selection between ZSTD_format_e input compression formats
	*/
	#define ZSTD_d_format ZSTD_d_experimentalParam1
	/* ZSTD_d_stableOutBuffer
	* Experimental parameter.
	* Default is 0 == disabled. Set to 1 to enable.
	*
	* Tells the decompressor that the ZSTD_outBuffer will ALWAYS be the same
	* between calls, except for the modifications that zstd makes to pos (the
	* caller must not modify pos). This is checked by the decompressor, and
	* decompression will fail if it ever changes. Therefore the ZSTD_outBuffer
	* MUST be large enough to fit the entire decompressed frame. This will be
	* checked when the frame content size is known. The data in the ZSTD_outBuffer
	* in the range [dst, dst + pos) MUST not be modified during decompression
	* or you will get data corruption.
	*
	* When this flags is enabled zstd won't allocate an output buffer, because
	* it can write directly to the ZSTD_outBuffer, but it will still allocate
	* an input buffer large enough to fit any compressed block. This will also
	* avoid the memcpy() from the internal output buffer to the ZSTD_outBuffer.
	* If you need to avoid the input buffer allocation use the buffer-less
	* streaming API.
	*
	* NOTE: So long as the ZSTD_outBuffer always points to valid memory, using
	* this flag is ALWAYS memory safe, and will never access out-of-bounds
	* memory. However, decompression WILL fail if you violate the preconditions.
	*
	* WARNING: The data in the ZSTD_outBuffer in the range [dst, dst + pos) MUST
	* not be modified during decompression or you will get data corruption. This
	* is because zstd needs to reference data in the ZSTD_outBuffer to regenerate
	* matches. Normally zstd maintains its own buffer for this purpose, but passing
	* this flag tells zstd to use the user provided buffer.
	*/
	#define ZSTD_d_stableOutBuffer ZSTD_d_experimentalParam2

	/*! ZSTD_DCtx_setFormat() :
	* Instruct the decoder context about what kind of data to decode next.
	* This instruction is mandatory to decode data without a fully-formed header,
	* such ZSTD_f_zstd1_magicless for example.
	* @return : 0, or an error code (which can be tested using ZSTD_isError()). */
	ZSTDLIB_API size_t ZSTD_DCtx_setFormat(ZSTD_DCtx* dctx, ZSTD_format_e format);

	/*! ZSTD_decompressStream_simpleArgs() :
	* Same as ZSTD_decompressStream(),
	* but using only integral types as arguments.
	* This can be helpful for binders from dynamic languages
	* which have troubles handling structures containing memory pointers.
	*/
	ZSTDLIB_API size_t ZSTD_decompressStream_simpleArgs (
	ZSTD_DCtx* dctx,
	void* dst, size_t dstCapacity, size_t* dstPos,
	const void* src, size_t srcSize, size_t* srcPos);


	/********************************************************************
	* Advanced streaming functions
	* Warning : most of these functions are now redundant with the Advanced API.
	* Once Advanced API reaches "stable" status,
	* redundant functions will be deprecated, and then at some point removed.
	********************************************************************/

	/===== Advanced Streaming compression functions =====/
	/**! ZSTD_initCStream_srcSize() :
	* This function is deprecated, and equivalent to:
	* ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);
	* ZSTD_CCtx_refCDict(zcs, NULL); // clear the dictionary (if any)
	* ZSTD_CCtx_setParameter(zcs, ZSTD_c_compressionLevel, compressionLevel);
	* ZSTD_CCtx_setPledgedSrcSize(zcs, pledgedSrcSize);
	*
	* pledgedSrcSize must be correct. If it is not known at init time, use
	* ZSTD_CONTENTSIZE_UNKNOWN. Note that, for compatibility with older programs,
	* "0" also disables frame content size field. It may be enabled in the future.
	* Note : this prototype will be marked as deprecated and generate compilation warnings on reaching v1.5.x
	*/
	ZSTDLIB_API size_t
	ZSTD_initCStream_srcSize(ZSTD_CStream* zcs,
	int compressionLevel,
	unsigned long long pledgedSrcSize);

	/**! ZSTD_initCStream_usingDict() :
	* This function is deprecated, and is equivalent to:
	* ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);
	* ZSTD_CCtx_setParameter(zcs, ZSTD_c_compressionLevel, compressionLevel);
	* ZSTD_CCtx_loadDictionary(zcs, dict, dictSize);
	*
	* Creates of an internal CDict (incompatible with static CCtx), except if
	* dict == NULL or dictSize < 8, in which case no dict is used.
	* Note: dict is loaded with ZSTD_dct_auto (treated as a full zstd dictionary if
	* it begins with ZSTD_MAGIC_DICTIONARY, else as raw content) and ZSTD_dlm_byCopy.
	* Note : this prototype will be marked as deprecated and generate compilation warnings on reaching v1.5.x
	*/
	ZSTDLIB_API size_t
	ZSTD_initCStream_usingDict(ZSTD_CStream* zcs,
	const void* dict, size_t dictSize,
	int compressionLevel);

	/**! ZSTD_initCStream_advanced() :
	* This function is deprecated, and is approximately equivalent to:
	* ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);
	* // Pseudocode: Set each zstd parameter and leave the rest as-is.
	* for ((param, value) : params) {
	* ZSTD_CCtx_setParameter(zcs, param, value);
	* }
	* ZSTD_CCtx_setPledgedSrcSize(zcs, pledgedSrcSize);
	* ZSTD_CCtx_loadDictionary(zcs, dict, dictSize);
	*
	* dict is loaded with ZSTD_dct_auto and ZSTD_dlm_byCopy.
	* pledgedSrcSize must be correct.
	* If srcSize is not known at init time, use value ZSTD_CONTENTSIZE_UNKNOWN.
	* Note : this prototype will be marked as deprecated and generate compilation warnings on reaching v1.5.x
	*/
	ZSTDLIB_API size_t
	ZSTD_initCStream_advanced(ZSTD_CStream* zcs,
	const void* dict, size_t dictSize,
	ZSTD_parameters params,
	unsigned long long pledgedSrcSize);

	/**! ZSTD_initCStream_usingCDict() :
	* This function is deprecated, and equivalent to:
	* ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);
	* ZSTD_CCtx_refCDict(zcs, cdict);
	*
	* note : cdict will just be referenced, and must outlive compression session
	* Note : this prototype will be marked as deprecated and generate compilation warnings on reaching v1.5.x
	*/
	ZSTDLIB_API size_t ZSTD_initCStream_usingCDict(ZSTD_CStream* zcs, const ZSTD_CDict* cdict);

	/**! ZSTD_initCStream_usingCDict_advanced() :
	* This function is DEPRECATED, and is approximately equivalent to:
	* ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);
	* // Pseudocode: Set each zstd frame parameter and leave the rest as-is.
	* for ((fParam, value) : fParams) {
	* ZSTD_CCtx_setParameter(zcs, fParam, value);
	* }
	* ZSTD_CCtx_setPledgedSrcSize(zcs, pledgedSrcSize);
	* ZSTD_CCtx_refCDict(zcs, cdict);
	*
	* same as ZSTD_initCStream_usingCDict(), with control over frame parameters.
	* pledgedSrcSize must be correct. If srcSize is not known at init time, use
	* value ZSTD_CONTENTSIZE_UNKNOWN.
	* Note : this prototype will be marked as deprecated and generate compilation warnings on reaching v1.5.x
	*/
	ZSTDLIB_API size_t
	ZSTD_initCStream_usingCDict_advanced(ZSTD_CStream* zcs,
	const ZSTD_CDict* cdict,
	ZSTD_frameParameters fParams,
	unsigned long long pledgedSrcSize);

	/*! ZSTD_resetCStream() :
	* This function is deprecated, and is equivalent to:
	* ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);
	* ZSTD_CCtx_setPledgedSrcSize(zcs, pledgedSrcSize);
	*
	* start a new frame, using same parameters from previous frame.
	* This is typically useful to skip dictionary loading stage, since it will re-use it in-place.
	* Note that zcs must be init at least once before using ZSTD_resetCStream().
	* If pledgedSrcSize is not known at reset time, use macro ZSTD_CONTENTSIZE_UNKNOWN.
	* If pledgedSrcSize > 0, its value must be correct, as it will be written in header, and controlled at the end.
	* For the time being, pledgedSrcSize==0 is interpreted as "srcSize unknown" for compatibility with older programs,
	* but it will change to mean "empty" in future version, so use macro ZSTD_CONTENTSIZE_UNKNOWN instead.
	* @return : 0, or an error code (which can be tested using ZSTD_isError())
	* Note : this prototype will be marked as deprecated and generate compilation warnings on reaching v1.5.x
	*/
	ZSTDLIB_API size_t ZSTD_resetCStream(ZSTD_CStream* zcs, unsigned long long pledgedSrcSize);


	typedef struct {
	unsigned long long ingested; /* nb input bytes read and buffered */
	unsigned long long consumed; /* nb input bytes actually compressed */
	unsigned long long produced; /* nb of compressed bytes generated and buffered */
	unsigned long long flushed; /* nb of compressed bytes flushed : not provided; can be tracked from caller side */
	unsigned currentJobID; /* MT only : latest started job nb */
	unsigned nbActiveWorkers; /* MT only : nb of workers actively compressing at probe time */
	} ZSTD_frameProgression;

	/* ZSTD_getFrameProgression() :
	* tells how much data has been ingested (read from input)
	* consumed (input actually compressed) and produced (output) for current frame.
	* Note : (ingested - consumed) is amount of input data buffered internally, not yet compressed.
	* Aggregates progression inside active worker threads.
	*/
	ZSTDLIB_API ZSTD_frameProgression ZSTD_getFrameProgression(const ZSTD_CCtx* cctx);

	/*! ZSTD_toFlushNow() :
	* Tell how many bytes are ready to be flushed immediately.
	* Useful for multithreading scenarios (nbWorkers >= 1).
	* Probe the oldest active job, defined as oldest job not yet entirely flushed,
	* and check its output buffer.
	* @return : amount of data stored in oldest job and ready to be flushed immediately.
	* if @return == 0, it means either :
	* + there is no active job (could be checked with ZSTD_frameProgression()), or
	* + oldest job is still actively compressing data,
	* but everything it has produced has also been flushed so far,
	* therefore flush speed is limited by production speed of oldest job
	* irrespective of the speed of concurrent (and newer) jobs.
	*/
	ZSTDLIB_API size_t ZSTD_toFlushNow(ZSTD_CCtx* cctx);


	/===== Advanced Streaming decompression functions =====/
	/**
	* This function is deprecated, and is equivalent to:
	*
	* ZSTD_DCtx_reset(zds, ZSTD_reset_session_only);
	* ZSTD_DCtx_loadDictionary(zds, dict, dictSize);
	*
	* note: no dictionary will be used if dict == NULL or dictSize < 8
	* Note : this prototype will be marked as deprecated and generate compilation warnings on reaching v1.5.x
	*/
	ZSTDLIB_API size_t ZSTD_initDStream_usingDict(ZSTD_DStream* zds, const void* dict, size_t dictSize);

	/**
	* This function is deprecated, and is equivalent to:
	*
	* ZSTD_DCtx_reset(zds, ZSTD_reset_session_only);
	* ZSTD_DCtx_refDDict(zds, ddict);
	*
	* note : ddict is referenced, it must outlive decompression session
	* Note : this prototype will be marked as deprecated and generate compilation warnings on reaching v1.5.x
	*/
	ZSTDLIB_API size_t ZSTD_initDStream_usingDDict(ZSTD_DStream* zds, const ZSTD_DDict* ddict);

	/**
	* This function is deprecated, and is equivalent to:
	*
	* ZSTD_DCtx_reset(zds, ZSTD_reset_session_only);
	*
	* re-use decompression parameters from previous init; saves dictionary loading
	* Note : this prototype will be marked as deprecated and generate compilation warnings on reaching v1.5.x
	*/
	ZSTDLIB_API size_t ZSTD_resetDStream(ZSTD_DStream* zds);


	/*********************************************************************
	* Buffer-less and synchronous inner streaming functions
	*
	* This is an advanced API, giving full control over buffer management, for users which need direct control over memory.
	* But it's also a complex one, with several restrictions, documented below.
	* Prefer normal streaming API for an easier experience.
	********************************************************************* */

	/**
	Buffer-less streaming compression (synchronous mode)

	A ZSTD_CCtx object is required to track streaming operations.
	Use ZSTD_createCCtx() / ZSTD_freeCCtx() to manage resource.
	ZSTD_CCtx object can be re-used multiple times within successive compression operations.

	Start by initializing a context.
	Use ZSTD_compressBegin(), or ZSTD_compressBegin_usingDict() for dictionary compression,
	or ZSTD_compressBegin_advanced(), for finer parameter control.
	It's also possible to duplicate a reference context which has already been initialized, using ZSTD_copyCCtx()

	Then, consume your input using ZSTD_compressContinue().
	There are some important considerations to keep in mind when using this advanced function :
	- ZSTD_compressContinue() has no internal buffer. It uses externally provided buffers only.
	- Interface is synchronous : input is consumed entirely and produces 1+ compressed blocks.
	- Caller must ensure there is enough space in `dst` to store compressed data under worst case scenario.
	Worst case evaluation is provided by ZSTD_compressBound().
	ZSTD_compressContinue() doesn't guarantee recover after a failed compression.
	- ZSTD_compressContinue() presumes prior input *is still accessible and unmodified* (up to maximum distance size, see WindowLog).
	It remembers all previous contiguous blocks, plus one separated memory segment (which can itself consists of multiple contiguous blocks)
	- ZSTD_compressContinue() detects that prior input has been overwritten when `src` buffer overlaps.
	In which case, it will "discard" the relevant memory section from its history.

	Finish a frame with ZSTD_compressEnd(), which will write the last block(s) and optional checksum.
	It's possible to use srcSize==0, in which case, it will write a final empty block to end the frame.
	Without last block mark, frames are considered unfinished (hence corrupted) by compliant decoders.

	`ZSTD_CCtx` object can be re-used (ZSTD_compressBegin()) to compress again.
	*/

	/===== Buffer-less streaming compression functions =====/
	ZSTDLIB_API size_t ZSTD_compressBegin(ZSTD_CCtx* cctx, int compressionLevel);
	ZSTDLIB_API size_t ZSTD_compressBegin_usingDict(ZSTD_CCtx* cctx, const void* dict, size_t dictSize, int compressionLevel);
	ZSTDLIB_API size_t ZSTD_compressBegin_advanced(ZSTD_CCtx* cctx, const void* dict, size_t dictSize, ZSTD_parameters params, unsigned long long pledgedSrcSize); /*< pledgedSrcSize : If srcSize is not known at init time, use ZSTD_CONTENTSIZE_UNKNOWN /
	ZSTDLIB_API size_t ZSTD_compressBegin_usingCDict(ZSTD_CCtx* cctx, const ZSTD_CDict* cdict); /*< note: fails if cdict==NULL /
	ZSTDLIB_API size_t ZSTD_compressBegin_usingCDict_advanced(ZSTD_CCtx* const cctx, const ZSTD_CDict* const cdict, ZSTD_frameParameters const fParams, unsigned long long const pledgedSrcSize); /* compression parameters are already set within cdict. pledgedSrcSize must be correct. If srcSize is not known, use macro ZSTD_CONTENTSIZE_UNKNOWN */
	ZSTDLIB_API size_t ZSTD_copyCCtx(ZSTD_CCtx* cctx, const ZSTD_CCtx* preparedCCtx, unsigned long long pledgedSrcSize); /*< note: if pledgedSrcSize is not known, use ZSTD_CONTENTSIZE_UNKNOWN /

	ZSTDLIB_API size_t ZSTD_compressContinue(ZSTD_CCtx* cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);
	ZSTDLIB_API size_t ZSTD_compressEnd(ZSTD_CCtx* cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);


	/*-
	Buffer-less streaming decompression (synchronous mode)

	A ZSTD_DCtx object is required to track streaming operations.
	Use ZSTD_createDCtx() / ZSTD_freeDCtx() to manage it.
	A ZSTD_DCtx object can be re-used multiple times.

	First typical operation is to retrieve frame parameters, using ZSTD_getFrameHeader().
	Frame header is extracted from the beginning of compressed frame, so providing only the frame's beginning is enough.
	Data fragment must be large enough to ensure successful decoding.
	`ZSTD_frameHeaderSize_max` bytes is guaranteed to always be large enough.
	@result : 0 : successful decoding, the `ZSTD_frameHeader` structure is correctly filled.
	>0 : `srcSize` is too small, please provide at least @result bytes on next attempt.
	errorCode, which can be tested using ZSTD_isError().

	It fills a ZSTD_frameHeader structure with important information to correctly decode the frame,
	such as the dictionary ID, content size, or maximum back-reference distance (`windowSize`).
	Note that these values could be wrong, either because of data corruption, or because a 3rd party deliberately spoofs false information.
	As a consequence, check that values remain within valid application range.
	For example, do not allocate memory blindly, check that `windowSize` is within expectation.
	Each application can set its own limits, depending on local restrictions.
	For extended interoperability, it is recommended to support `windowSize` of at least 8 MB.

	ZSTD_decompressContinue() needs previous data blocks during decompression, up to `windowSize` bytes.
	ZSTD_decompressContinue() is very sensitive to contiguity,
	if 2 blocks don't follow each other, make sure that either the compressor breaks contiguity at the same place,
	or that previous contiguous segment is large enough to properly handle maximum back-reference distance.
	There are multiple ways to guarantee this condition.

	The most memory efficient way is to use a round buffer of sufficient size.
	Sufficient size is determined by invoking ZSTD_decodingBufferSize_min(),
	which can @return an error code if required value is too large for current system (in 32-bits mode).
	In a round buffer methodology, ZSTD_decompressContinue() decompresses each block next to previous one,
	up to the moment there is not enough room left in the buffer to guarantee decoding another full block,
	which maximum size is provided in `ZSTD_frameHeader` structure, field `blockSizeMax`.
	At which point, decoding can resume from the beginning of the buffer.
	Note that already decoded data stored in the buffer should be flushed before being overwritten.

	There are alternatives possible, for example using two or more buffers of size `windowSize` each, though they consume more memory.

	Finally, if you control the compression process, you can also ignore all buffer size rules,
	as long as the encoder and decoder progress in "lock-step",
	aka use exactly the same buffer sizes, break contiguity at the same place, etc.

	Once buffers are setup, start decompression, with ZSTD_decompressBegin().
	If decompression requires a dictionary, use ZSTD_decompressBegin_usingDict() or ZSTD_decompressBegin_usingDDict().

	Then use ZSTD_nextSrcSizeToDecompress() and ZSTD_decompressContinue() alternatively.
	ZSTD_nextSrcSizeToDecompress() tells how many bytes to provide as 'srcSize' to ZSTD_decompressContinue().
	ZSTD_decompressContinue() requires this _exact_ amount of bytes, or it will fail.

	@result of ZSTD_decompressContinue() is the number of bytes regenerated within 'dst' (necessarily <= dstCapacity).
	It can be zero : it just means ZSTD_decompressContinue() has decoded some metadata item.
	It can also be an error code, which can be tested with ZSTD_isError().

	A frame is fully decoded when ZSTD_nextSrcSizeToDecompress() returns zero.
	Context can then be reset to start a new decompression.

	Note : it's possible to know if next input to present is a header or a block, using ZSTD_nextInputType().
	This information is not required to properly decode a frame.

	== Special case : skippable frames ==

	Skippable frames allow integration of user-defined data into a flow of concatenated frames.
	Skippable frames will be ignored (skipped) by decompressor.
	The format of skippable frames is as follows :
	a) Skippable frame ID - 4 Bytes, Little endian format, any value from 0x184D2A50 to 0x184D2A5F
	b) Frame Size - 4 Bytes, Little endian format, unsigned 32-bits
	c) Frame Content - any content (User Data) of length equal to Frame Size
	For skippable frames ZSTD_getFrameHeader() returns zfhPtr->frameType==ZSTD_skippableFrame.
	For skippable frames ZSTD_decompressContinue() always returns 0 : it only skips the content.
	*/

	/===== Buffer-less streaming decompression functions =====/
	typedef enum { ZSTD_frame, ZSTD_skippableFrame } ZSTD_frameType_e;
	typedef struct {
	unsigned long long frameContentSize; /* if == ZSTD_CONTENTSIZE_UNKNOWN, it means this field is not available. 0 means "empty" */
	unsigned long long windowSize; /* can be very large, up to <= frameContentSize */
	unsigned blockSizeMax;
	ZSTD_frameType_e frameType; /* if == ZSTD_skippableFrame, frameContentSize is the size of skippable content */
	unsigned headerSize;
	unsigned dictID;
	unsigned checksumFlag;
	} ZSTD_frameHeader;

	/*! ZSTD_getFrameHeader() :
	* decode Frame Header, or requires larger `srcSize`.
	* @return : 0, `zfhPtr` is correctly filled,
	* >0, `srcSize` is too small, value is wanted `srcSize` amount,
	* or an error code, which can be tested using ZSTD_isError() */
	ZSTDLIB_API size_t ZSTD_getFrameHeader(ZSTD_frameHeader* zfhPtr, const void* src, size_t srcSize); /*< doesn't consume input /
	/*! ZSTD_getFrameHeader_advanced() :
	* same as ZSTD_getFrameHeader(),
	* with added capability to select a format (like ZSTD_f_zstd1_magicless) */
	ZSTDLIB_API size_t ZSTD_getFrameHeader_advanced(ZSTD_frameHeader* zfhPtr, const void* src, size_t srcSize, ZSTD_format_e format);
	ZSTDLIB_API size_t ZSTD_decodingBufferSize_min(unsigned long long windowSize, unsigned long long frameContentSize); /*< when frame content size is not known, pass in frameContentSize == ZSTD_CONTENTSIZE_UNKNOWN /

	ZSTDLIB_API size_t ZSTD_decompressBegin(ZSTD_DCtx* dctx);
	ZSTDLIB_API size_t ZSTD_decompressBegin_usingDict(ZSTD_DCtx* dctx, const void* dict, size_t dictSize);
	ZSTDLIB_API size_t ZSTD_decompressBegin_usingDDict(ZSTD_DCtx* dctx, const ZSTD_DDict* ddict);

	ZSTDLIB_API size_t ZSTD_nextSrcSizeToDecompress(ZSTD_DCtx* dctx);
	ZSTDLIB_API size_t ZSTD_decompressContinue(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);

	/* misc */
	ZSTDLIB_API void ZSTD_copyDCtx(ZSTD_DCtx* dctx, const ZSTD_DCtx* preparedDCtx);
	typedef enum { ZSTDnit_frameHeader, ZSTDnit_blockHeader, ZSTDnit_block, ZSTDnit_lastBlock, ZSTDnit_checksum, ZSTDnit_skippableFrame } ZSTD_nextInputType_e;
	ZSTDLIB_API ZSTD_nextInputType_e ZSTD_nextInputType(ZSTD_DCtx* dctx);




	/* ============================ */
	/** Block level API */
	/* ============================ */

	/*!
	Block functions produce and decode raw zstd blocks, without frame metadata.
	Frame metadata cost is typically ~12 bytes, which can be non-negligible for very small blocks (< 100 bytes).
	But users will have to take in charge needed metadata to regenerate data, such as compressed and content sizes.

	A few rules to respect :
	- Compressing and decompressing require a context structure
	+ Use ZSTD_createCCtx() and ZSTD_createDCtx()
	- It is necessary to init context before starting
	+ compression : any ZSTD_compressBegin*() variant, including with dictionary
	+ decompression : any ZSTD_decompressBegin*() variant, including with dictionary
	+ copyCCtx() and copyDCtx() can be used too
	- Block size is limited, it must be <= ZSTD_getBlockSize() <= ZSTD_BLOCKSIZE_MAX == 128 KB
	+ If input is larger than a block size, it's necessary to split input data into multiple blocks
	+ For inputs larger than a single block, consider using regular ZSTD_compress() instead.
	Frame metadata is not that costly, and quickly becomes negligible as source size grows larger than a block.
	- When a block is considered not compressible enough, ZSTD_compressBlock() result will be 0 (zero) !
	===> In which case, nothing is produced into `dst` !
	+ User __must__ test for such outcome and deal directly with uncompressed data
	+ A block cannot be declared incompressible if ZSTD_compressBlock() return value was != 0.
	Doing so would mess up with statistics history, leading to potential data corruption.
	+ ZSTD_decompressBlock() _doesn't accept uncompressed data as input_ !!
	+ In case of multiple successive blocks, should some of them be uncompressed,
	decoder must be informed of their existence in order to follow proper history.
	Use ZSTD_insertBlock() for such a case.
	*/

	/===== Raw zstd block functions =====/
	ZSTDLIB_API size_t ZSTD_getBlockSize (const ZSTD_CCtx* cctx);
	ZSTDLIB_API size_t ZSTD_compressBlock (ZSTD_CCtx* cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);
	ZSTDLIB_API size_t ZSTD_decompressBlock(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);
	ZSTDLIB_API size_t ZSTD_insertBlock (ZSTD_DCtx* dctx, const void* blockStart, size_t blockSize); /*< insert uncompressed block into `dctx` history. Useful for multi-blocks decompression. /


	#endif /* ZSTD_H_ZSTD_STATIC_LINKING_ONLY */

	#if defined (__cplusplus)
	}
	#endif
	/** ended inlining ../zstd.h **/
	#define FSE_STATIC_LINKING_ONLY
	/** skipping file: fse.h **/
	#define HUF_STATIC_LINKING_ONLY
	/** skipping file: huf.h **/
	#ifndef XXH_STATIC_LINKING_ONLY
	# define XXH_STATIC_LINKING_ONLY /* XXH64_state_t */
	#endif
	/** start inlining xxhash.h **/
	/*
	* xxHash - Extremely Fast Hash algorithm
	* Header File
	* Copyright (c) 2012-2020, Yann Collet, Facebook, Inc.
	*
	* You can contact the author at :
	* - xxHash source repository : https://github.com/Cyan4973/xxHash
	*
	* This source code is licensed under both the BSD-style license (found in the
	* LICENSE file in the root directory of this source tree) and the GPLv2 (found
	* in the COPYING file in the root directory of this source tree).
	* You may select, at your option, one of the above-listed licenses.
	*/

	/* Notice extracted from xxHash homepage :

	xxHash is an extremely fast Hash algorithm, running at RAM speed limits.
	It also successfully passes all tests from the SMHasher suite.

	Comparison (single thread, Windows Seven 32 bits, using SMHasher on a Core 2 Duo @3GHz)

	Name Speed Q.Score Author
	xxHash 5.4 GB/s 10
	CrapWow 3.2 GB/s 2 Andrew
	MumurHash 3a 2.7 GB/s 10 Austin Appleby
	SpookyHash 2.0 GB/s 10 Bob Jenkins
	SBox 1.4 GB/s 9 Bret Mulvey
	Lookup3 1.2 GB/s 9 Bob Jenkins
	SuperFastHash 1.2 GB/s 1 Paul Hsieh
	CityHash64 1.05 GB/s 10 Pike & Alakuijala
	FNV 0.55 GB/s 5 Fowler, Noll, Vo
	CRC32 0.43 GB/s 9
	MD5-32 0.33 GB/s 10 Ronald L. Rivest
	SHA1-32 0.28 GB/s 10

	Q.Score is a measure of quality of the hash function.
	It depends on successfully passing SMHasher test set.
	10 is a perfect score.

	A 64-bits version, named XXH64, is available since r35.
	It offers much better speed, but for 64-bits applications only.
	Name Speed on 64 bits Speed on 32 bits
	XXH64 13.8 GB/s 1.9 GB/s
	XXH32 6.8 GB/s 6.0 GB/s
	*/

	#if defined (__cplusplus)
	extern "C" {
	#endif

	#ifndef XXHASH_H_5627135585666179
	#define XXHASH_H_5627135585666179 1


	/* ****************************
	* Definitions
	******************************/
	#include <stddef.h> /* size_t */
	typedef enum { XXH_OK=0, XXH_ERROR } XXH_errorcode;


	/* ****************************
	* API modifier
	******************************/
	/** XXH_PRIVATE_API
	* This is useful if you want to include xxhash functions in `static` mode
	* in order to inline them, and remove their symbol from the public list.
	* Methodology :
	* #define XXH_PRIVATE_API
	* #include "xxhash.h"
	* `xxhash.c` is automatically included.
	* It's not useful to compile and link it as a separate module anymore.
	*/
	#ifdef XXH_PRIVATE_API
	# ifndef XXH_STATIC_LINKING_ONLY
	# define XXH_STATIC_LINKING_ONLY
	# endif
	# if defined(__GNUC__)
	# define XXH_PUBLIC_API static __inline __attribute__((unused))
	# elif defined (__cplusplus) \|\| (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
	# define XXH_PUBLIC_API static inline
	# elif defined(_MSC_VER)
	# define XXH_PUBLIC_API static __inline
	# else
	# define XXH_PUBLIC_API static /* this version may generate warnings for unused static functions; disable the relevant warning */
	# endif
	#else
	# define XXH_PUBLIC_API /* do nothing */
	#endif /* XXH_PRIVATE_API */

	/*!XXH_NAMESPACE, aka Namespace Emulation :

	If you want to include _and expose_ xxHash functions from within your own library,
	but also want to avoid symbol collisions with another library which also includes xxHash,

	you can use XXH_NAMESPACE, to automatically prefix any public symbol from xxhash library
	with the value of XXH_NAMESPACE (so avoid to keep it NULL and avoid numeric values).

	Note that no change is required within the calling program as long as it includes `xxhash.h` :
	regular symbol name will be automatically translated by this header.
	*/
	#ifdef XXH_NAMESPACE
	# define XXH_CAT(A,B) A##B
	# define XXH_NAME2(A,B) XXH_CAT(A,B)
	# define XXH32 XXH_NAME2(XXH_NAMESPACE, XXH32)
	# define XXH64 XXH_NAME2(XXH_NAMESPACE, XXH64)
	# define XXH_versionNumber XXH_NAME2(XXH_NAMESPACE, XXH_versionNumber)
	# define XXH32_createState XXH_NAME2(XXH_NAMESPACE, XXH32_createState)
	# define XXH64_createState XXH_NAME2(XXH_NAMESPACE, XXH64_createState)
	# define XXH32_freeState XXH_NAME2(XXH_NAMESPACE, XXH32_freeState)
	# define XXH64_freeState XXH_NAME2(XXH_NAMESPACE, XXH64_freeState)
	# define XXH32_reset XXH_NAME2(XXH_NAMESPACE, XXH32_reset)
	# define XXH64_reset XXH_NAME2(XXH_NAMESPACE, XXH64_reset)
	# define XXH32_update XXH_NAME2(XXH_NAMESPACE, XXH32_update)
	# define XXH64_update XXH_NAME2(XXH_NAMESPACE, XXH64_update)
	# define XXH32_digest XXH_NAME2(XXH_NAMESPACE, XXH32_digest)
	# define XXH64_digest XXH_NAME2(XXH_NAMESPACE, XXH64_digest)
	# define XXH32_copyState XXH_NAME2(XXH_NAMESPACE, XXH32_copyState)
	# define XXH64_copyState XXH_NAME2(XXH_NAMESPACE, XXH64_copyState)
	# define XXH32_canonicalFromHash XXH_NAME2(XXH_NAMESPACE, XXH32_canonicalFromHash)
	# define XXH64_canonicalFromHash XXH_NAME2(XXH_NAMESPACE, XXH64_canonicalFromHash)
	# define XXH32_hashFromCanonical XXH_NAME2(XXH_NAMESPACE, XXH32_hashFromCanonical)
	# define XXH64_hashFromCanonical XXH_NAME2(XXH_NAMESPACE, XXH64_hashFromCanonical)
	#endif


	/* *************************************
	* Version
	***************************************/
	#define XXH_VERSION_MAJOR 0
	#define XXH_VERSION_MINOR 6
	#define XXH_VERSION_RELEASE 2
	#define XXH_VERSION_NUMBER (XXH_VERSION_MAJOR 100100 + XXH_VERSION_MINOR *100 + XXH_VERSION_RELEASE)
	XXH_PUBLIC_API unsigned XXH_versionNumber (void);


	/* ****************************
	* Simple Hash Functions
	******************************/
	typedef unsigned int XXH32_hash_t;
	typedef unsigned long long XXH64_hash_t;

	XXH_PUBLIC_API XXH32_hash_t XXH32 (const void* input, size_t length, unsigned int seed);
	XXH_PUBLIC_API XXH64_hash_t XXH64 (const void* input, size_t length, unsigned long long seed);

	/*!
	XXH32() :
	Calculate the 32-bits hash of sequence "length" bytes stored at memory address "input".
	The memory between input & input+length must be valid (allocated and read-accessible).
	"seed" can be used to alter the result predictably.
	Speed on Core 2 Duo @ 3 GHz (single thread, SMHasher benchmark) : 5.4 GB/s
	XXH64() :
	Calculate the 64-bits hash of sequence of length "len" stored at memory address "input".
	"seed" can be used to alter the result predictably.
	This function runs 2x faster on 64-bits systems, but slower on 32-bits systems (see benchmark).
	*/


	/* ****************************
	* Streaming Hash Functions
	******************************/
	typedef struct XXH32_state_s XXH32_state_t; /* incomplete type */
	typedef struct XXH64_state_s XXH64_state_t; /* incomplete type */

	/! State allocation, compatible with dynamic libraries /

	XXH_PUBLIC_API XXH32_state_t* XXH32_createState(void);
	XXH_PUBLIC_API XXH_errorcode XXH32_freeState(XXH32_state_t* statePtr);

	XXH_PUBLIC_API XXH64_state_t* XXH64_createState(void);
	XXH_PUBLIC_API XXH_errorcode XXH64_freeState(XXH64_state_t* statePtr);


	/* hash streaming */

	XXH_PUBLIC_API XXH_errorcode XXH32_reset (XXH32_state_t* statePtr, unsigned int seed);
	XXH_PUBLIC_API XXH_errorcode XXH32_update (XXH32_state_t* statePtr, const void* input, size_t length);
	XXH_PUBLIC_API XXH32_hash_t XXH32_digest (const XXH32_state_t* statePtr);

	XXH_PUBLIC_API XXH_errorcode XXH64_reset (XXH64_state_t* statePtr, unsigned long long seed);
	XXH_PUBLIC_API XXH_errorcode XXH64_update (XXH64_state_t* statePtr, const void* input, size_t length);
	XXH_PUBLIC_API XXH64_hash_t XXH64_digest (const XXH64_state_t* statePtr);

	/*
	These functions generate the xxHash of an input provided in multiple segments.
	Note that, for small input, they are slower than single-call functions, due to state management.
	For small input, prefer `XXH32()` and `XXH64()` .

	XXH state must first be allocated, using XXH*_createState() .

	Start a new hash by initializing state with a seed, using XXH*_reset().

	Then, feed the hash state by calling XXH*_update() as many times as necessary.
	Obviously, input must be allocated and read accessible.
	The function returns an error code, with 0 meaning OK, and any other value meaning there is an error.

	Finally, a hash value can be produced anytime, by using XXH*_digest().
	This function returns the nn-bits hash as an int or long long.

	It's still possible to continue inserting input into the hash state after a digest,
	and generate some new hashes later on, by calling again XXH*_digest().

	When done, free XXH state space if it was allocated dynamically.
	*/


	/* **************************
	* Utils
	****************************/
	#if !(defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) /* ! C99 */
	# define restrict /* disable restrict */
	#endif

	XXH_PUBLIC_API void XXH32_copyState(XXH32_state_t* restrict dst_state, const XXH32_state_t* restrict src_state);
	XXH_PUBLIC_API void XXH64_copyState(XXH64_state_t* restrict dst_state, const XXH64_state_t* restrict src_state);


	/* **************************
	* Canonical representation
	****************************/
	/* Default result type for XXH functions are primitive unsigned 32 and 64 bits.
	* The canonical representation uses human-readable write convention, aka big-endian (large digits first).
	* These functions allow transformation of hash result into and from its canonical format.
	* This way, hash values can be written into a file / memory, and remain comparable on different systems and programs.
	*/
	typedef struct { unsigned char digest[4]; } XXH32_canonical_t;
	typedef struct { unsigned char digest[8]; } XXH64_canonical_t;

	XXH_PUBLIC_API void XXH32_canonicalFromHash(XXH32_canonical_t* dst, XXH32_hash_t hash);
	XXH_PUBLIC_API void XXH64_canonicalFromHash(XXH64_canonical_t* dst, XXH64_hash_t hash);

	XXH_PUBLIC_API XXH32_hash_t XXH32_hashFromCanonical(const XXH32_canonical_t* src);
	XXH_PUBLIC_API XXH64_hash_t XXH64_hashFromCanonical(const XXH64_canonical_t* src);

	#endif /* XXHASH_H_5627135585666179 */



	/* ================================================================================================
	This section contains definitions which are not guaranteed to remain stable.
	They may change in future versions, becoming incompatible with a different version of the library.
	They shall only be used with static linking.
	Never use these definitions in association with dynamic linking !
	=================================================================================================== */
	#if defined(XXH_STATIC_LINKING_ONLY) && !defined(XXH_STATIC_H_3543687687345)
	#define XXH_STATIC_H_3543687687345

	/* These definitions are only meant to allow allocation of XXH state
	statically, on stack, or in a struct for example.
	Do not use members directly. */

	struct XXH32_state_s {
	unsigned total_len_32;
	unsigned large_len;
	unsigned v1;
	unsigned v2;
	unsigned v3;
	unsigned v4;
	unsigned mem32[4]; /* buffer defined as U32 for alignment */
	unsigned memsize;
	unsigned reserved; /* never read nor write, will be removed in a future version */
	}; /* typedef'd to XXH32_state_t */

	struct XXH64_state_s {
	unsigned long long total_len;
	unsigned long long v1;
	unsigned long long v2;
	unsigned long long v3;
	unsigned long long v4;
	unsigned long long mem64[4]; /* buffer defined as U64 for alignment */
	unsigned memsize;
	unsigned reserved[2]; /* never read nor write, will be removed in a future version */
	}; /* typedef'd to XXH64_state_t */


	# ifdef XXH_PRIVATE_API
	/** start inlining xxhash.c **/
	/*
	* xxHash - Fast Hash algorithm
	* Copyright (c) 2012-2020, Yann Collet, Facebook, Inc.
	*
	* You can contact the author at :
	* - xxHash homepage: http://www.xxhash.com
	* - xxHash source repository : https://github.com/Cyan4973/xxHash
	*
	* This source code is licensed under both the BSD-style license (found in the
	* LICENSE file in the root directory of this source tree) and the GPLv2 (found
	* in the COPYING file in the root directory of this source tree).
	* You may select, at your option, one of the above-listed licenses.
	*/


	/* *************************************
	* Tuning parameters
	***************************************/
	/*!XXH_FORCE_MEMORY_ACCESS :
	* By default, access to unaligned memory is controlled by `memcpy()`, which is safe and portable.
	* Unfortunately, on some target/compiler combinations, the generated assembly is sub-optimal.
	* The below switch allow to select different access method for improved performance.
	* Method 0 (default) : use `memcpy()`. Safe and portable.
	* Method 1 : `__packed` statement. It depends on compiler extension (ie, not portable).
	* This method is safe if your compiler supports it, and generally as fast or faster than `memcpy`.
	* Method 2 : direct access. This method doesn't depend on compiler but violate C standard.
	* It can generate buggy code on targets which do not support unaligned memory accesses.
	* But in some circumstances, it's the only known way to get the most performance (ie GCC + ARMv6)
	* See http://stackoverflow.com/a/32095106/646947 for details.
	* Prefer these methods in priority order (0 > 1 > 2)
	*/
	#ifndef XXH_FORCE_MEMORY_ACCESS /* can be defined externally, on command line for example */
	# if defined(__GNUC__) && ( defined(__ARM_ARCH_6__) \|\| defined(__ARM_ARCH_6J__) \|\| defined(__ARM_ARCH_6K__) \|\| defined(__ARM_ARCH_6Z__) \|\| defined(__ARM_ARCH_6ZK__) \|\| defined(__ARM_ARCH_6T2__) )
	# define XXH_FORCE_MEMORY_ACCESS 2
	# elif (defined(__INTEL_COMPILER) && !defined(WIN32)) \|\| \
	(defined(__GNUC__) && ( defined(__ARM_ARCH_7__) \|\| defined(__ARM_ARCH_7A__) \|\| defined(__ARM_ARCH_7R__) \|\| defined(__ARM_ARCH_7M__) \|\| defined(__ARM_ARCH_7S__) )) \|\| \
	defined(__ICCARM__)
	# define XXH_FORCE_MEMORY_ACCESS 1
	# endif
	#endif

	/*!XXH_ACCEPT_NULL_INPUT_POINTER :
	* If the input pointer is a null pointer, xxHash default behavior is to trigger a memory access error, since it is a bad pointer.
	* When this option is enabled, xxHash output for null input pointers will be the same as a null-length input.
	* By default, this option is disabled. To enable it, uncomment below define :
	*/
	/* #define XXH_ACCEPT_NULL_INPUT_POINTER 1 */

	/*!XXH_FORCE_NATIVE_FORMAT :
	* By default, xxHash library provides endian-independent Hash values, based on little-endian convention.
	* Results are therefore identical for little-endian and big-endian CPU.
	* This comes at a performance cost for big-endian CPU, since some swapping is required to emulate little-endian format.
	* Should endian-independence be of no importance for your application, you may set the #define below to 1,
	* to improve speed for Big-endian CPU.
	* This option has no impact on Little_Endian CPU.
	*/
	#ifndef XXH_FORCE_NATIVE_FORMAT /* can be defined externally */
	# define XXH_FORCE_NATIVE_FORMAT 0
	#endif

	/*!XXH_FORCE_ALIGN_CHECK :
	* This is a minor performance trick, only useful with lots of very small keys.
	* It means : check for aligned/unaligned input.
	* The check costs one initial branch per hash; set to 0 when the input data
	* is guaranteed to be aligned.
	*/
	#ifndef XXH_FORCE_ALIGN_CHECK /* can be defined externally */
	# if defined(__i386) \|\| defined(_M_IX86) \|\| defined(__x86_64__) \|\| defined(_M_X64)
	# define XXH_FORCE_ALIGN_CHECK 0
	# else
	# define XXH_FORCE_ALIGN_CHECK 1
	# endif
	#endif


	/* *************************************
	* Includes & Memory related functions
	***************************************/
	/* Modify the local functions below should you wish to use some other memory routines */
	/* for malloc(), free() */
	#include <stdlib.h>
	#include <stddef.h> /* size_t */
	static void* XXH_malloc(size_t s) { return malloc(s); }
	static void XXH_free (void* p) { free(p); }
	/* for memcpy() */
	#include <string.h>
	static void* XXH_memcpy(void* dest, const void* src, size_t size) { return memcpy(dest,src,size); }

	#ifndef XXH_STATIC_LINKING_ONLY
	# define XXH_STATIC_LINKING_ONLY
	#endif
	/** skipping file: xxhash.h **/


	/* *************************************
	* Compiler Specific Options
	***************************************/
	#if (defined(__GNUC__) && !defined(__STRICT_ANSI__)) \|\| defined(__cplusplus) \|\| defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L /* C99 */
	# define INLINE_KEYWORD inline
	#else
	# define INLINE_KEYWORD
	#endif

	#if defined(__GNUC__) \|\| defined(__ICCARM__)
	# define FORCE_INLINE_ATTR __attribute__((always_inline))
	#elif defined(_MSC_VER)
	# define FORCE_INLINE_ATTR __forceinline
	#else
	# define FORCE_INLINE_ATTR
	#endif

	#define FORCE_INLINE_TEMPLATE static INLINE_KEYWORD FORCE_INLINE_ATTR


	#ifdef _MSC_VER
	# pragma warning(disable : 4127) /* disable: C4127: conditional expression is constant */
	#endif


	/* *************************************
	* Basic Types
	***************************************/
	#ifndef MEM_MODULE
	# define MEM_MODULE
	# if !defined (__VMS) && (defined (__cplusplus) \|\| (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) )
	# include <stdint.h>
	typedef uint8_t BYTE;
	typedef uint16_t U16;
	typedef uint32_t U32;
	typedef int32_t S32;
	typedef uint64_t U64;
	# else
	typedef unsigned char BYTE;
	typedef unsigned short U16;
	typedef unsigned int U32;
	typedef signed int S32;
	typedef unsigned long long U64; /* if your compiler doesn't support unsigned long long, replace by another 64-bit type here. Note that xxhash.h will also need to be updated. */
	# endif
	#endif


	#if (defined(XXH_FORCE_MEMORY_ACCESS) && (XXH_FORCE_MEMORY_ACCESS==2))

	/* Force direct memory access. Only works on CPU which support unaligned memory access in hardware */
	static U32 XXH_read32(const void* memPtr) { return (const U32) memPtr; }
	static U64 XXH_read64(const void* memPtr) { return (const U64) memPtr; }

	#elif (defined(XXH_FORCE_MEMORY_ACCESS) && (XXH_FORCE_MEMORY_ACCESS==1))

	/* __pack instructions are safer, but compiler specific, hence potentially problematic for some compilers */
	/* currently only defined for gcc and icc */
	typedef union { U32 u32; U64 u64; } __attribute__((packed)) unalign;

	static U32 XXH_read32(const void* ptr) { return ((const unalign*)ptr)->u32; }
	static U64 XXH_read64(const void* ptr) { return ((const unalign*)ptr)->u64; }

	#else

	/* portable and safe solution. Generally efficient.
	* see : http://stackoverflow.com/a/32095106/646947
	*/

	static U32 XXH_read32(const void* memPtr)
	{
	U32 val;
	memcpy(&val, memPtr, sizeof(val));
	return val;
	}

	static U64 XXH_read64(const void* memPtr)
	{
	U64 val;
	memcpy(&val, memPtr, sizeof(val));
	return val;
	}

	#endif /* XXH_FORCE_DIRECT_MEMORY_ACCESS */


	/* ****************************************
	* Compiler-specific Functions and Macros
	******************************************/
	#define GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)

	/* Note : although _rotl exists for minGW (GCC under windows), performance seems poor */
	#if defined(_MSC_VER)
	# define XXH_rotl32(x,r) _rotl(x,r)
	# define XXH_rotl64(x,r) _rotl64(x,r)
	#else
	#if defined(__ICCARM__)
	# include <intrinsics.h>
	# define XXH_rotl32(x,r) __ROR(x,(32 - r))
	#else
	# define XXH_rotl32(x,r) ((x << r) \| (x >> (32 - r)))
	#endif
	# define XXH_rotl64(x,r) ((x << r) \| (x >> (64 - r)))
	#endif

	#if defined(_MSC_VER) /* Visual Studio */
	# define XXH_swap32 _byteswap_ulong
	# define XXH_swap64 _byteswap_uint64
	#elif GCC_VERSION >= 403
	# define XXH_swap32 __builtin_bswap32
	# define XXH_swap64 __builtin_bswap64
	#else
	static U32 XXH_swap32 (U32 x)
	{
	return ((x << 24) & 0xff000000 ) \|
	((x << 8) & 0x00ff0000 ) \|
	((x >> 8) & 0x0000ff00 ) \|
	((x >> 24) & 0x000000ff );
	}
	static U64 XXH_swap64 (U64 x)
	{
	return ((x << 56) & 0xff00000000000000ULL) \|
	((x << 40) & 0x00ff000000000000ULL) \|
	((x << 24) & 0x0000ff0000000000ULL) \|
	((x << 8) & 0x000000ff00000000ULL) \|
	((x >> 8) & 0x00000000ff000000ULL) \|
	((x >> 24) & 0x0000000000ff0000ULL) \|
	((x >> 40) & 0x000000000000ff00ULL) \|
	((x >> 56) & 0x00000000000000ffULL);
	}
	#endif


	/* *************************************
	* Architecture Macros
	***************************************/
	typedef enum { XXH_bigEndian=0, XXH_littleEndian=1 } XXH_endianess;

	/* XXH_CPU_LITTLE_ENDIAN can be defined externally, for example on the compiler command line */
	#ifndef XXH_CPU_LITTLE_ENDIAN
	static const int g_one = 1;
	# define XXH_CPU_LITTLE_ENDIAN ((const char)(&g_one))
	#endif


	/* ***************************
	* Memory reads
	*****************************/
	typedef enum { XXH_aligned, XXH_unaligned } XXH_alignment;

	FORCE_INLINE_TEMPLATE U32 XXH_readLE32_align(const void* ptr, XXH_endianess endian, XXH_alignment align)
	{
	if (align==XXH_unaligned)
	return endian==XXH_littleEndian ? XXH_read32(ptr) : XXH_swap32(XXH_read32(ptr));
	else
	return endian==XXH_littleEndian ? (const U32)ptr : XXH_swap32((const U32)ptr);
	}

	FORCE_INLINE_TEMPLATE U32 XXH_readLE32(const void* ptr, XXH_endianess endian)
	{
	return XXH_readLE32_align(ptr, endian, XXH_unaligned);
	}

	static U32 XXH_readBE32(const void* ptr)
	{
	return XXH_CPU_LITTLE_ENDIAN ? XXH_swap32(XXH_read32(ptr)) : XXH_read32(ptr);
	}

	FORCE_INLINE_TEMPLATE U64 XXH_readLE64_align(const void* ptr, XXH_endianess endian, XXH_alignment align)
	{
	if (align==XXH_unaligned)
	return endian==XXH_littleEndian ? XXH_read64(ptr) : XXH_swap64(XXH_read64(ptr));
	else
	return endian==XXH_littleEndian ? (const U64)ptr : XXH_swap64((const U64)ptr);
	}

	FORCE_INLINE_TEMPLATE U64 XXH_readLE64(const void* ptr, XXH_endianess endian)
	{
	return XXH_readLE64_align(ptr, endian, XXH_unaligned);
	}

	static U64 XXH_readBE64(const void* ptr)
	{
	return XXH_CPU_LITTLE_ENDIAN ? XXH_swap64(XXH_read64(ptr)) : XXH_read64(ptr);
	}


	/* *************************************
	* Macros
	***************************************/
	#define XXH_STATIC_ASSERT(c) { enum { XXH_static_assert = 1/(int)(!!(c)) }; } /* use only after variable declarations */


	/* *************************************
	* Constants
	***************************************/
	static const U32 PRIME32_1 = 2654435761U;
	static const U32 PRIME32_2 = 2246822519U;
	static const U32 PRIME32_3 = 3266489917U;
	static const U32 PRIME32_4 = 668265263U;
	static const U32 PRIME32_5 = 374761393U;

	static const U64 PRIME64_1 = 11400714785074694791ULL;
	static const U64 PRIME64_2 = 14029467366897019727ULL;
	static const U64 PRIME64_3 = 1609587929392839161ULL;
	static const U64 PRIME64_4 = 9650029242287828579ULL;
	static const U64 PRIME64_5 = 2870177450012600261ULL;

	XXH_PUBLIC_API unsigned XXH_versionNumber (void) { return XXH_VERSION_NUMBER; }


	/* **************************
	* Utils
	****************************/
	XXH_PUBLIC_API void XXH32_copyState(XXH32_state_t* restrict dstState, const XXH32_state_t* restrict srcState)
	{
	memcpy(dstState, srcState, sizeof(*dstState));
	}

	XXH_PUBLIC_API void XXH64_copyState(XXH64_state_t* restrict dstState, const XXH64_state_t* restrict srcState)
	{
	memcpy(dstState, srcState, sizeof(*dstState));
	}


	/* ***************************
	* Simple Hash Functions
	*****************************/

	static U32 XXH32_round(U32 seed, U32 input)
	{
	seed += input * PRIME32_2;
	seed = XXH_rotl32(seed, 13);
	seed *= PRIME32_1;
	return seed;
	}

	FORCE_INLINE_TEMPLATE U32 XXH32_endian_align(const void* input, size_t len, U32 seed, XXH_endianess endian, XXH_alignment align)
	{
	const BYTE* p = (const BYTE*)input;
	const BYTE* bEnd = p + len;
	U32 h32;
	#define XXH_get32bits(p) XXH_readLE32_align(p, endian, align)

	#ifdef XXH_ACCEPT_NULL_INPUT_POINTER
	if (p==NULL) {
	len=0;
	bEnd=p=(const BYTE*)(size_t)16;
	}
	#endif

	if (len>=16) {
	const BYTE* const limit = bEnd - 16;
	U32 v1 = seed + PRIME32_1 + PRIME32_2;
	U32 v2 = seed + PRIME32_2;
	U32 v3 = seed + 0;
	U32 v4 = seed - PRIME32_1;

	do {
	v1 = XXH32_round(v1, XXH_get32bits(p)); p+=4;
	v2 = XXH32_round(v2, XXH_get32bits(p)); p+=4;
	v3 = XXH32_round(v3, XXH_get32bits(p)); p+=4;
	v4 = XXH32_round(v4, XXH_get32bits(p)); p+=4;
	} while (p<=limit);

	h32 = XXH_rotl32(v1, 1) + XXH_rotl32(v2, 7) + XXH_rotl32(v3, 12) + XXH_rotl32(v4, 18);
	} else {
	h32 = seed + PRIME32_5;
	}

	h32 += (U32) len;

	while (p+4<=bEnd) {
	h32 += XXH_get32bits(p) * PRIME32_3;
	h32 = XXH_rotl32(h32, 17) * PRIME32_4 ;
	p+=4;
	}

	while (p<bEnd) {
	h32 += (p) PRIME32_5;
	h32 = XXH_rotl32(h32, 11) * PRIME32_1 ;
	p++;
	}

	h32 ^= h32 >> 15;
	h32 *= PRIME32_2;
	h32 ^= h32 >> 13;
	h32 *= PRIME32_3;
	h32 ^= h32 >> 16;

	return h32;
	}


	XXH_PUBLIC_API unsigned int XXH32 (const void* input, size_t len, unsigned int seed)
	{
	#if 0
	/* Simple version, good for code maintenance, but unfortunately slow for small inputs */
	XXH32_CREATESTATE_STATIC(state);
	XXH32_reset(state, seed);
	XXH32_update(state, input, len);
	return XXH32_digest(state);
	#else
	XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;

	if (XXH_FORCE_ALIGN_CHECK) {
	if ((((size_t)input) & 3) == 0) { /* Input is 4-bytes aligned, leverage the speed benefit */
	if ((endian_detected==XXH_littleEndian) \|\| XXH_FORCE_NATIVE_FORMAT)
	return XXH32_endian_align(input, len, seed, XXH_littleEndian, XXH_aligned);
	else
	return XXH32_endian_align(input, len, seed, XXH_bigEndian, XXH_aligned);
	} }

	if ((endian_detected==XXH_littleEndian) \|\| XXH_FORCE_NATIVE_FORMAT)
	return XXH32_endian_align(input, len, seed, XXH_littleEndian, XXH_unaligned);
	else
	return XXH32_endian_align(input, len, seed, XXH_bigEndian, XXH_unaligned);
	#endif
	}


	static U64 XXH64_round(U64 acc, U64 input)
	{
	acc += input * PRIME64_2;
	acc = XXH_rotl64(acc, 31);
	acc *= PRIME64_1;
	return acc;
	}

	static U64 XXH64_mergeRound(U64 acc, U64 val)
	{
	val = XXH64_round(0, val);
	acc ^= val;
	acc = acc * PRIME64_1 + PRIME64_4;
	return acc;
	}

	FORCE_INLINE_TEMPLATE U64 XXH64_endian_align(const void* input, size_t len, U64 seed, XXH_endianess endian, XXH_alignment align)
	{
	const BYTE* p = (const BYTE*)input;
	const BYTE* const bEnd = p + len;
	U64 h64;
	#define XXH_get64bits(p) XXH_readLE64_align(p, endian, align)

	#ifdef XXH_ACCEPT_NULL_INPUT_POINTER
	if (p==NULL) {
	len=0;
	bEnd=p=(const BYTE*)(size_t)32;
	}
	#endif

	if (len>=32) {
	const BYTE* const limit = bEnd - 32;
	U64 v1 = seed + PRIME64_1 + PRIME64_2;
	U64 v2 = seed + PRIME64_2;
	U64 v3 = seed + 0;
	U64 v4 = seed - PRIME64_1;

	do {
	v1 = XXH64_round(v1, XXH_get64bits(p)); p+=8;
	v2 = XXH64_round(v2, XXH_get64bits(p)); p+=8;
	v3 = XXH64_round(v3, XXH_get64bits(p)); p+=8;
	v4 = XXH64_round(v4, XXH_get64bits(p)); p+=8;
	} while (p<=limit);

	h64 = XXH_rotl64(v1, 1) + XXH_rotl64(v2, 7) + XXH_rotl64(v3, 12) + XXH_rotl64(v4, 18);
	h64 = XXH64_mergeRound(h64, v1);
	h64 = XXH64_mergeRound(h64, v2);
	h64 = XXH64_mergeRound(h64, v3);
	h64 = XXH64_mergeRound(h64, v4);

	} else {
	h64 = seed + PRIME64_5;
	}

	h64 += (U64) len;

	while (p+8<=bEnd) {
	U64 const k1 = XXH64_round(0, XXH_get64bits(p));
	h64 ^= k1;
	h64 = XXH_rotl64(h64,27) * PRIME64_1 + PRIME64_4;
	p+=8;
	}

	if (p+4<=bEnd) {
	h64 ^= (U64)(XXH_get32bits(p)) * PRIME64_1;
	h64 = XXH_rotl64(h64, 23) * PRIME64_2 + PRIME64_3;
	p+=4;
	}

	while (p<bEnd) {
	h64 ^= (p) PRIME64_5;
	h64 = XXH_rotl64(h64, 11) * PRIME64_1;
	p++;
	}

	h64 ^= h64 >> 33;
	h64 *= PRIME64_2;
	h64 ^= h64 >> 29;
	h64 *= PRIME64_3;
	h64 ^= h64 >> 32;

	return h64;
	}


	XXH_PUBLIC_API unsigned long long XXH64 (const void* input, size_t len, unsigned long long seed)
	{
	#if 0
	/* Simple version, good for code maintenance, but unfortunately slow for small inputs */
	XXH64_CREATESTATE_STATIC(state);
	XXH64_reset(state, seed);
	XXH64_update(state, input, len);
	return XXH64_digest(state);
	#else
	XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;

	if (XXH_FORCE_ALIGN_CHECK) {
	if ((((size_t)input) & 7)==0) { /* Input is aligned, let's leverage the speed advantage */
	if ((endian_detected==XXH_littleEndian) \|\| XXH_FORCE_NATIVE_FORMAT)
	return XXH64_endian_align(input, len, seed, XXH_littleEndian, XXH_aligned);
	else
	return XXH64_endian_align(input, len, seed, XXH_bigEndian, XXH_aligned);
	} }

	if ((endian_detected==XXH_littleEndian) \|\| XXH_FORCE_NATIVE_FORMAT)
	return XXH64_endian_align(input, len, seed, XXH_littleEndian, XXH_unaligned);
	else
	return XXH64_endian_align(input, len, seed, XXH_bigEndian, XXH_unaligned);
	#endif
	}


	/* **************************************************
	* Advanced Hash Functions
	****************************************************/

	XXH_PUBLIC_API XXH32_state_t* XXH32_createState(void)
	{
	return (XXH32_state_t*)XXH_malloc(sizeof(XXH32_state_t));
	}
	XXH_PUBLIC_API XXH_errorcode XXH32_freeState(XXH32_state_t* statePtr)
	{
	XXH_free(statePtr);
	return XXH_OK;
	}

	XXH_PUBLIC_API XXH64_state_t* XXH64_createState(void)
	{
	return (XXH64_state_t*)XXH_malloc(sizeof(XXH64_state_t));
	}
	XXH_PUBLIC_API XXH_errorcode XXH64_freeState(XXH64_state_t* statePtr)
	{
	XXH_free(statePtr);
	return XXH_OK;
	}


	/* Hash feed */

	XXH_PUBLIC_API XXH_errorcode XXH32_reset(XXH32_state_t* statePtr, unsigned int seed)
	{
	XXH32_state_t state; /* using a local state to memcpy() in order to avoid strict-aliasing warnings */
	memset(&state, 0, sizeof(state)-4); /* do not write into reserved, for future removal */
	state.v1 = seed + PRIME32_1 + PRIME32_2;
	state.v2 = seed + PRIME32_2;
	state.v3 = seed + 0;
	state.v4 = seed - PRIME32_1;
	memcpy(statePtr, &state, sizeof(state));
	return XXH_OK;
	}


	XXH_PUBLIC_API XXH_errorcode XXH64_reset(XXH64_state_t* statePtr, unsigned long long seed)
	{
	XXH64_state_t state; /* using a local state to memcpy() in order to avoid strict-aliasing warnings */
	memset(&state, 0, sizeof(state)-8); /* do not write into reserved, for future removal */
	state.v1 = seed + PRIME64_1 + PRIME64_2;
	state.v2 = seed + PRIME64_2;
	state.v3 = seed + 0;
	state.v4 = seed - PRIME64_1;
	memcpy(statePtr, &state, sizeof(state));
	return XXH_OK;
	}


	FORCE_INLINE_TEMPLATE XXH_errorcode XXH32_update_endian (XXH32_state_t* state, const void* input, size_t len, XXH_endianess endian)
	{
	const BYTE* p = (const BYTE*)input;
	const BYTE* const bEnd = p + len;

	#ifdef XXH_ACCEPT_NULL_INPUT_POINTER
	if (input==NULL) return XXH_ERROR;
	#endif

	state->total_len_32 += (unsigned)len;
	state->large_len \|= (len>=16) \| (state->total_len_32>=16);

	if (state->memsize + len < 16) { /* fill in tmp buffer */
	XXH_memcpy((BYTE*)(state->mem32) + state->memsize, input, len);
	state->memsize += (unsigned)len;
	return XXH_OK;
	}

	if (state->memsize) { /* some data left from previous update */
	XXH_memcpy((BYTE*)(state->mem32) + state->memsize, input, 16-state->memsize);
	{ const U32* p32 = state->mem32;
	state->v1 = XXH32_round(state->v1, XXH_readLE32(p32, endian)); p32++;
	state->v2 = XXH32_round(state->v2, XXH_readLE32(p32, endian)); p32++;
	state->v3 = XXH32_round(state->v3, XXH_readLE32(p32, endian)); p32++;
	state->v4 = XXH32_round(state->v4, XXH_readLE32(p32, endian)); p32++;
	}
	p += 16-state->memsize;
	state->memsize = 0;
	}

	if (p <= bEnd-16) {
	const BYTE* const limit = bEnd - 16;
	U32 v1 = state->v1;
	U32 v2 = state->v2;
	U32 v3 = state->v3;
	U32 v4 = state->v4;

	do {
	v1 = XXH32_round(v1, XXH_readLE32(p, endian)); p+=4;
	v2 = XXH32_round(v2, XXH_readLE32(p, endian)); p+=4;
	v3 = XXH32_round(v3, XXH_readLE32(p, endian)); p+=4;
	v4 = XXH32_round(v4, XXH_readLE32(p, endian)); p+=4;
	} while (p<=limit);

	state->v1 = v1;
	state->v2 = v2;
	state->v3 = v3;
	state->v4 = v4;
	}

	if (p < bEnd) {
	XXH_memcpy(state->mem32, p, (size_t)(bEnd-p));
	state->memsize = (unsigned)(bEnd-p);
	}

	return XXH_OK;
	}

	XXH_PUBLIC_API XXH_errorcode XXH32_update (XXH32_state_t* state_in, const void* input, size_t len)
	{
	XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;

	if ((endian_detected==XXH_littleEndian) \|\| XXH_FORCE_NATIVE_FORMAT)
	return XXH32_update_endian(state_in, input, len, XXH_littleEndian);
	else
	return XXH32_update_endian(state_in, input, len, XXH_bigEndian);
	}



	FORCE_INLINE_TEMPLATE U32 XXH32_digest_endian (const XXH32_state_t* state, XXH_endianess endian)
	{
	const BYTE * p = (const BYTE*)state->mem32;
	const BYTE* const bEnd = (const BYTE*)(state->mem32) + state->memsize;
	U32 h32;

	if (state->large_len) {
	h32 = XXH_rotl32(state->v1, 1) + XXH_rotl32(state->v2, 7) + XXH_rotl32(state->v3, 12) + XXH_rotl32(state->v4, 18);
	} else {
	h32 = state->v3 /* == seed */ + PRIME32_5;
	}

	h32 += state->total_len_32;

	while (p+4<=bEnd) {
	h32 += XXH_readLE32(p, endian) * PRIME32_3;
	h32 = XXH_rotl32(h32, 17) * PRIME32_4;
	p+=4;
	}

	while (p<bEnd) {
	h32 += (p) PRIME32_5;
	h32 = XXH_rotl32(h32, 11) * PRIME32_1;
	p++;
	}

	h32 ^= h32 >> 15;
	h32 *= PRIME32_2;
	h32 ^= h32 >> 13;
	h32 *= PRIME32_3;
	h32 ^= h32 >> 16;

	return h32;
	}


	XXH_PUBLIC_API unsigned int XXH32_digest (const XXH32_state_t* state_in)
	{
	XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;

	if ((endian_detected==XXH_littleEndian) \|\| XXH_FORCE_NATIVE_FORMAT)
	return XXH32_digest_endian(state_in, XXH_littleEndian);
	else
	return XXH32_digest_endian(state_in, XXH_bigEndian);
	}



	/* ** XXH64 ** */

	FORCE_INLINE_TEMPLATE XXH_errorcode XXH64_update_endian (XXH64_state_t* state, const void* input, size_t len, XXH_endianess endian)
	{
	const BYTE* p = (const BYTE*)input;
	const BYTE* const bEnd = p + len;

	#ifdef XXH_ACCEPT_NULL_INPUT_POINTER
	if (input==NULL) return XXH_ERROR;
	#endif

	state->total_len += len;

	if (state->memsize + len < 32) { /* fill in tmp buffer */
	if (input != NULL) {
	XXH_memcpy(((BYTE*)state->mem64) + state->memsize, input, len);
	}
	state->memsize += (U32)len;
	return XXH_OK;
	}

	if (state->memsize) { /* tmp buffer is full */
	XXH_memcpy(((BYTE*)state->mem64) + state->memsize, input, 32-state->memsize);
	state->v1 = XXH64_round(state->v1, XXH_readLE64(state->mem64+0, endian));
	state->v2 = XXH64_round(state->v2, XXH_readLE64(state->mem64+1, endian));
	state->v3 = XXH64_round(state->v3, XXH_readLE64(state->mem64+2, endian));
	state->v4 = XXH64_round(state->v4, XXH_readLE64(state->mem64+3, endian));
	p += 32-state->memsize;
	state->memsize = 0;
	}

	if (p+32 <= bEnd) {
	const BYTE* const limit = bEnd - 32;
	U64 v1 = state->v1;
	U64 v2 = state->v2;
	U64 v3 = state->v3;
	U64 v4 = state->v4;

	do {
	v1 = XXH64_round(v1, XXH_readLE64(p, endian)); p+=8;
	v2 = XXH64_round(v2, XXH_readLE64(p, endian)); p+=8;
	v3 = XXH64_round(v3, XXH_readLE64(p, endian)); p+=8;
	v4 = XXH64_round(v4, XXH_readLE64(p, endian)); p+=8;
	} while (p<=limit);

	state->v1 = v1;
	state->v2 = v2;
	state->v3 = v3;
	state->v4 = v4;
	}

	if (p < bEnd) {
	XXH_memcpy(state->mem64, p, (size_t)(bEnd-p));
	state->memsize = (unsigned)(bEnd-p);
	}

	return XXH_OK;
	}

	XXH_PUBLIC_API XXH_errorcode XXH64_update (XXH64_state_t* state_in, const void* input, size_t len)
	{
	XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;

	if ((endian_detected==XXH_littleEndian) \|\| XXH_FORCE_NATIVE_FORMAT)
	return XXH64_update_endian(state_in, input, len, XXH_littleEndian);
	else
	return XXH64_update_endian(state_in, input, len, XXH_bigEndian);
	}



	FORCE_INLINE_TEMPLATE U64 XXH64_digest_endian (const XXH64_state_t* state, XXH_endianess endian)
	{
	const BYTE * p = (const BYTE*)state->mem64;
	const BYTE* const bEnd = (const BYTE*)state->mem64 + state->memsize;
	U64 h64;

	if (state->total_len >= 32) {
	U64 const v1 = state->v1;
	U64 const v2 = state->v2;
	U64 const v3 = state->v3;
	U64 const v4 = state->v4;

	h64 = XXH_rotl64(v1, 1) + XXH_rotl64(v2, 7) + XXH_rotl64(v3, 12) + XXH_rotl64(v4, 18);
	h64 = XXH64_mergeRound(h64, v1);
	h64 = XXH64_mergeRound(h64, v2);
	h64 = XXH64_mergeRound(h64, v3);
	h64 = XXH64_mergeRound(h64, v4);
	} else {
	h64 = state->v3 + PRIME64_5;
	}

	h64 += (U64) state->total_len;

	while (p+8<=bEnd) {
	U64 const k1 = XXH64_round(0, XXH_readLE64(p, endian));
	h64 ^= k1;
	h64 = XXH_rotl64(h64,27) * PRIME64_1 + PRIME64_4;
	p+=8;
	}

	if (p+4<=bEnd) {
	h64 ^= (U64)(XXH_readLE32(p, endian)) * PRIME64_1;
	h64 = XXH_rotl64(h64, 23) * PRIME64_2 + PRIME64_3;
	p+=4;
	}

	while (p<bEnd) {
	h64 ^= (p) PRIME64_5;
	h64 = XXH_rotl64(h64, 11) * PRIME64_1;
	p++;
	}

	h64 ^= h64 >> 33;
	h64 *= PRIME64_2;
	h64 ^= h64 >> 29;
	h64 *= PRIME64_3;
	h64 ^= h64 >> 32;

	return h64;
	}


	XXH_PUBLIC_API unsigned long long XXH64_digest (const XXH64_state_t* state_in)
	{
	XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;

	if ((endian_detected==XXH_littleEndian) \|\| XXH_FORCE_NATIVE_FORMAT)
	return XXH64_digest_endian(state_in, XXH_littleEndian);
	else
	return XXH64_digest_endian(state_in, XXH_bigEndian);
	}


	/* **************************
	* Canonical representation
	****************************/

	/*! Default XXH result types are basic unsigned 32 and 64 bits.
	* The canonical representation follows human-readable write convention, aka big-endian (large digits first).
	* These functions allow transformation of hash result into and from its canonical format.
	* This way, hash values can be written into a file or buffer, and remain comparable across different systems and programs.
	*/

	XXH_PUBLIC_API void XXH32_canonicalFromHash(XXH32_canonical_t* dst, XXH32_hash_t hash)
	{
	XXH_STATIC_ASSERT(sizeof(XXH32_canonical_t) == sizeof(XXH32_hash_t));
	if (XXH_CPU_LITTLE_ENDIAN) hash = XXH_swap32(hash);
	memcpy(dst, &hash, sizeof(*dst));
	}

	XXH_PUBLIC_API void XXH64_canonicalFromHash(XXH64_canonical_t* dst, XXH64_hash_t hash)
	{
	XXH_STATIC_ASSERT(sizeof(XXH64_canonical_t) == sizeof(XXH64_hash_t));
	if (XXH_CPU_LITTLE_ENDIAN) hash = XXH_swap64(hash);
	memcpy(dst, &hash, sizeof(*dst));
	}

	XXH_PUBLIC_API XXH32_hash_t XXH32_hashFromCanonical(const XXH32_canonical_t* src)
	{
	return XXH_readBE32(src);
	}

	XXH_PUBLIC_API XXH64_hash_t XXH64_hashFromCanonical(const XXH64_canonical_t* src)
	{
	return XXH_readBE64(src);
	}
	/** ended inlining xxhash.c **/
	# endif

	#endif /* XXH_STATIC_LINKING_ONLY && XXH_STATIC_H_3543687687345 */


	#if defined (__cplusplus)
	}
	#endif
	/** ended inlining xxhash.h **/

	#if defined (__cplusplus)
	extern "C" {
	#endif

	/* ---- static assert (debug) --- */
	#define ZSTD_STATIC_ASSERT(c) DEBUG_STATIC_ASSERT(c)
	-#define ZSTD_isError ERR_isError /* for inlining */
	#define FSE_isError ERR_isError
	#define HUF_isError ERR_isError


	/-************************************
	* shared macros
	***************************************/
	#undef MIN
	#undef MAX
	#define MIN(a,b) ((a)<(b) ? (a) : (b))
	#define MAX(a,b) ((a)>(b) ? (a) : (b))

	/**
	* Ignore: this is an internal helper.
	*
	* This is a helper function to help force C99-correctness during compilation.
	* Under strict compilation modes, variadic macro arguments can't be empty.
	* However, variadic function arguments can be. Using a function therefore lets
	* us statically check that at least one (string) argument was passed,
	* independent of the compilation flags.
	*/
	static INLINE_KEYWORD UNUSED_ATTR
	void _force_has_format_string(const char *format, ...) {
	(void)format;
	}

	/**
	* Ignore: this is an internal helper.
	*
	* We want to force this function invocation to be syntactically correct, but
	* we don't want to force runtime evaluation of its arguments.
	*/
	#define _FORCE_HAS_FORMAT_STRING(...) \
	if (0) { \
	_force_has_format_string(__VA_ARGS__); \
	}

	/**
	* Return the specified error if the condition evaluates to true.
	*
	* In debug modes, prints additional information.
	* In order to do that (particularly, printing the conditional that failed),
	* this can't just wrap RETURN_ERROR().
	*/
	#define RETURN_ERROR_IF(cond, err, ...) \
	if (cond) { \
	RAWLOG(3, "%s:%d: ERROR!: check %s failed, returning %s", \
	__FILE__, __LINE__, ZSTD_QUOTE(cond), ZSTD_QUOTE(ERROR(err))); \
	_FORCE_HAS_FORMAT_STRING(__VA_ARGS__); \
	RAWLOG(3, ": " __VA_ARGS__); \
	RAWLOG(3, "\n"); \
	return ERROR(err); \
	}

	/**
	* Unconditionally return the specified error.
	*
	* In debug modes, prints additional information.
	*/
	#define RETURN_ERROR(err, ...) \
	do { \
	RAWLOG(3, "%s:%d: ERROR!: unconditional check failed, returning %s", \
	__FILE__, __LINE__, ZSTD_QUOTE(ERROR(err))); \
	_FORCE_HAS_FORMAT_STRING(__VA_ARGS__); \
	RAWLOG(3, ": " __VA_ARGS__); \
	RAWLOG(3, "\n"); \
	return ERROR(err); \
	} while(0);

	/**
	* If the provided expression evaluates to an error code, returns that error code.
	*
	* In debug modes, prints additional information.
	*/
	#define FORWARD_IF_ERROR(err, ...) \
	do { \
	size_t const err_code = (err); \
	if (ERR_isError(err_code)) { \
	RAWLOG(3, "%s:%d: ERROR!: forwarding error in %s: %s", \
	__FILE__, __LINE__, ZSTD_QUOTE(err), ERR_getErrorName(err_code)); \
	_FORCE_HAS_FORMAT_STRING(__VA_ARGS__); \
	RAWLOG(3, ": " __VA_ARGS__); \
	RAWLOG(3, "\n"); \
	return err_code; \
	} \
	} while(0);


	/-************************************
	* Common constants
	***************************************/
	#define ZSTD_OPT_NUM (1<<12)

	#define ZSTD_REP_NUM 3 /* number of repcodes */
	#define ZSTD_REP_MOVE (ZSTD_REP_NUM-1)
	static const U32 repStartValue[ZSTD_REP_NUM] = { 1, 4, 8 };

	#define KB *(1 <<10)
	#define MB *(1 <<20)
	#define GB *(1U<<30)

	#define BIT7 128
	#define BIT6 64
	#define BIT5 32
	#define BIT4 16
	#define BIT1 2
	#define BIT0 1

	#define ZSTD_WINDOWLOG_ABSOLUTEMIN 10
	static const size_t ZSTD_fcs_fieldSize[4] = { 0, 2, 4, 8 };
	static const size_t ZSTD_did_fieldSize[4] = { 0, 1, 2, 4 };

	#define ZSTD_FRAMEIDSIZE 4 /* magic number size */

	#define ZSTD_BLOCKHEADERSIZE 3 /* C standard doesn't allow `static const` variable to be init using another `static const` variable */
	static const size_t ZSTD_blockHeaderSize = ZSTD_BLOCKHEADERSIZE;
	typedef enum { bt_raw, bt_rle, bt_compressed, bt_reserved } blockType_e;

	#define ZSTD_FRAMECHECKSUMSIZE 4

	#define MIN_SEQUENCES_SIZE 1 /* nbSeq==0 */
	#define MIN_CBLOCK_SIZE (1 /litCSize/ + 1 /* RLE or RAW / + MIN_SEQUENCES_SIZE / nbSeq==0 /) / for a non-null block */

	#define HufLog 12
	typedef enum { set_basic, set_rle, set_compressed, set_repeat } symbolEncodingType_e;

	#define LONGNBSEQ 0x7F00

	#define MINMATCH 3

	#define Litbits 8
	#define MaxLit ((1<<Litbits) - 1)
	#define MaxML 52
	#define MaxLL 35
	#define DefaultMaxOff 28
	#define MaxOff 31
	#define MaxSeq MAX(MaxLL, MaxML) /* Assumption : MaxOff < MaxLL,MaxML */
	#define MLFSELog 9
	#define LLFSELog 9
	#define OffFSELog 8
	#define MaxFSELog MAX(MAX(MLFSELog, LLFSELog), OffFSELog)

	static const U32 LL_bits[MaxLL+1] = { 0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	1, 1, 1, 1, 2, 2, 3, 3,
	4, 6, 7, 8, 9,10,11,12,
	13,14,15,16 };
	static const S16 LL_defaultNorm[MaxLL+1] = { 4, 3, 2, 2, 2, 2, 2, 2,
	2, 2, 2, 2, 2, 1, 1, 1,
	2, 2, 2, 2, 2, 2, 2, 2,
	2, 3, 2, 1, 1, 1, 1, 1,
	-1,-1,-1,-1 };
	#define LL_DEFAULTNORMLOG 6 /* for static allocation */
	static const U32 LL_defaultNormLog = LL_DEFAULTNORMLOG;

	static const U32 ML_bits[MaxML+1] = { 0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	1, 1, 1, 1, 2, 2, 3, 3,
	4, 4, 5, 7, 8, 9,10,11,
	12,13,14,15,16 };
	static const S16 ML_defaultNorm[MaxML+1] = { 1, 4, 3, 2, 2, 2, 2, 2,
	2, 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 };
	#define ML_DEFAULTNORMLOG 6 /* for static allocation */
	static const U32 ML_defaultNormLog = ML_DEFAULTNORMLOG;

	static const S16 OF_defaultNorm[DefaultMaxOff+1] = { 1, 1, 1, 1, 1, 1, 2, 2,
	2, 1, 1, 1, 1, 1, 1, 1,
	1, 1, 1, 1, 1, 1, 1, 1,
	-1,-1,-1,-1,-1 };
	#define OF_DEFAULTNORMLOG 5 /* for static allocation */
	static const U32 OF_defaultNormLog = OF_DEFAULTNORMLOG;


	/-******************************************
	* Shared functions to include for inlining
	*********************************************/
	static void ZSTD_copy8(void* dst, const void* src) {
	#if !defined(ZSTD_NO_INTRINSICS) && defined(__ARM_NEON)
	vst1_u8((uint8_t)dst, vld1_u8((const uint8_t)src));
	#else
	memcpy(dst, src, 8);
	#endif
	}

	#define COPY8(d,s) { ZSTD_copy8(d,s); d+=8; s+=8; }
	static void ZSTD_copy16(void* dst, const void* src) {
	#if !defined(ZSTD_NO_INTRINSICS) && defined(__ARM_NEON)
	vst1q_u8((uint8_t)dst, vld1q_u8((const uint8_t)src));
	#else
	memcpy(dst, src, 16);
	#endif
	}
	#define COPY16(d,s) { ZSTD_copy16(d,s); d+=16; s+=16; }

	#define WILDCOPY_OVERLENGTH 32
	#define WILDCOPY_VECLEN 16

	typedef enum {
	ZSTD_no_overlap,
	ZSTD_overlap_src_before_dst
	/* ZSTD_overlap_dst_before_src, */
	} ZSTD_overlap_e;

	/*! ZSTD_wildcopy() :
	* Custom version of memcpy(), can over read/write up to WILDCOPY_OVERLENGTH bytes (if length==0)
	* @param ovtype controls the overlap detection
	* - ZSTD_no_overlap: The source and destination are guaranteed to be at least WILDCOPY_VECLEN bytes apart.
	* - ZSTD_overlap_src_before_dst: The src and dst may overlap, but they MUST be at least 8 bytes apart.
	* The src buffer must be before the dst buffer.
	*/
	MEM_STATIC FORCE_INLINE_ATTR
	void ZSTD_wildcopy(void* dst, const void* src, ptrdiff_t length, ZSTD_overlap_e const ovtype)
	{
	ptrdiff_t diff = (BYTE)dst - (const BYTE)src;
	const BYTE* ip = (const BYTE*)src;
	BYTE* op = (BYTE*)dst;
	BYTE* const oend = op + length;

	assert(diff >= 8 \|\| (ovtype == ZSTD_no_overlap && diff <= -WILDCOPY_VECLEN));

	if (ovtype == ZSTD_overlap_src_before_dst && diff < WILDCOPY_VECLEN) {
	/* Handle short offset copies. */
	do {
	COPY8(op, ip)
	} while (op < oend);
	} else {
	assert(diff >= WILDCOPY_VECLEN \|\| diff <= -WILDCOPY_VECLEN);
	/* Separate out the first COPY16() call because the copy length is
	* almost certain to be short, so the branches have different
	* probabilities. Since it is almost certain to be short, only do
	* one COPY16() in the first call. Then, do two calls per loop since
	* at that point it is more likely to have a high trip count.
	*/
	#ifndef __aarch64__
	do {
	COPY16(op, ip);
	}
	while (op < oend);
	#else
	COPY16(op, ip);
	if (op >= oend) return;
	do {
	COPY16(op, ip);
	COPY16(op, ip);
	}
	while (op < oend);
	#endif
	}
	}

	MEM_STATIC size_t ZSTD_limitCopy(void* dst, size_t dstCapacity, const void* src, size_t srcSize)
	{
	size_t const length = MIN(dstCapacity, srcSize);
	if (length > 0) {
	memcpy(dst, src, length);
	}
	return length;
	}

	/* define "workspace is too large" as this number of times larger than needed */
	#define ZSTD_WORKSPACETOOLARGE_FACTOR 3

	/* when workspace is continuously too large
	* during at least this number of times,
	* context's memory usage is considered wasteful,
	* because it's sized to handle a worst case scenario which rarely happens.
	* In which case, resize it down to free some memory */
	#define ZSTD_WORKSPACETOOLARGE_MAXDURATION 128


	/-******************************************
	* Private declarations
	*********************************************/
	typedef struct seqDef_s {
	U32 offset;
	U16 litLength;
	U16 matchLength;
	} seqDef;

	typedef struct {
	seqDef* sequencesStart;
	seqDef* sequences;
	BYTE* litStart;
	BYTE* lit;
	BYTE* llCode;
	BYTE* mlCode;
	BYTE* ofCode;
	size_t maxNbSeq;
	size_t maxNbLit;
	U32 longLengthID; /* 0 == no longLength; 1 == Lit.longLength; 2 == Match.longLength; */
	U32 longLengthPos;
	} seqStore_t;

	typedef struct {
	U32 litLength;
	U32 matchLength;
	} ZSTD_sequenceLength;

	/**
	* Returns the ZSTD_sequenceLength for the given sequences. It handles the decoding of long sequences
	* indicated by longLengthPos and longLengthID, and adds MINMATCH back to matchLength.
	*/
	MEM_STATIC ZSTD_sequenceLength ZSTD_getSequenceLength(seqStore_t const* seqStore, seqDef const* seq)
	{
	ZSTD_sequenceLength seqLen;
	seqLen.litLength = seq->litLength;
	seqLen.matchLength = seq->matchLength + MINMATCH;
	if (seqStore->longLengthPos == (U32)(seq - seqStore->sequencesStart)) {
	if (seqStore->longLengthID == 1) {
	seqLen.litLength += 0xFFFF;
	}
	if (seqStore->longLengthID == 2) {
	seqLen.matchLength += 0xFFFF;
	}
	}
	return seqLen;
	}

	/**
	* Contains the compressed frame size and an upper-bound for the decompressed frame size.
	* Note: before using `compressedSize`, check for errors using ZSTD_isError().
	* similarly, before using `decompressedBound`, check for errors using:
	* `decompressedBound != ZSTD_CONTENTSIZE_ERROR`
	*/
	typedef struct {
	size_t compressedSize;
	unsigned long long decompressedBound;
	} ZSTD_frameSizeInfo; /* decompress & legacy */

	const seqStore_t* ZSTD_getSeqStore(const ZSTD_CCtx* ctx); /* compress & dictBuilder */
	void ZSTD_seqToCodes(const seqStore_t* seqStorePtr); /* compress, dictBuilder, decodeCorpus (shouldn't get its definition from here) */

	/* custom memory allocation functions */
	void* ZSTD_malloc(size_t size, ZSTD_customMem customMem);
	void* ZSTD_calloc(size_t size, ZSTD_customMem customMem);
	void ZSTD_free(void* ptr, ZSTD_customMem customMem);


	MEM_STATIC U32 ZSTD_highbit32(U32 val) /* compress, dictBuilder, decodeCorpus */
	{
	assert(val != 0);
	{
	# if defined(_MSC_VER) /* Visual */
	unsigned long r=0;
	return _BitScanReverse(&r, val) ? (unsigned)r : 0;
	# elif defined(__GNUC__) && (__GNUC__ >= 3) /* GCC Intrinsic */
	return __builtin_clz (val) ^ 31;
	# elif defined(__ICCARM__) /* IAR Intrinsic */
	return 31 - __CLZ(val);
	# else /* Software version */
	static const U32 DeBruijnClz[32] = { 0, 9, 1, 10, 13, 21, 2, 29, 11, 14, 16, 18, 22, 25, 3, 30, 8, 12, 20, 28, 15, 17, 24, 7, 19, 27, 23, 6, 26, 5, 4, 31 };
	U32 v = val;
	v \|= v >> 1;
	v \|= v >> 2;
	v \|= v >> 4;
	v \|= v >> 8;
	v \|= v >> 16;
	return DeBruijnClz[(v * 0x07C4ACDDU) >> 27];
	# endif
	}
	}


	/* ZSTD_invalidateRepCodes() :
	* ensures next compression will not use repcodes from previous block.
	* Note : only works with regular variant;
	* do not use with extDict variant ! */
	void ZSTD_invalidateRepCodes(ZSTD_CCtx* cctx); /* zstdmt, adaptive_compression (shouldn't get this definition from here) */


	typedef struct {
	blockType_e blockType;
	U32 lastBlock;
	U32 origSize;
	} blockProperties_t; /* declared here for decompress and fullbench */

	/*! ZSTD_getcBlockSize() :
	* Provides the size of compressed block from block header `src` */
	/* Used by: decompress, fullbench (does not get its definition from here) */
	size_t ZSTD_getcBlockSize(const void* src, size_t srcSize,
	blockProperties_t* bpPtr);

	/*! ZSTD_decodeSeqHeaders() :
	* decode sequence header from src */
	/* Used by: decompress, fullbench (does not get its definition from here) */
	size_t ZSTD_decodeSeqHeaders(ZSTD_DCtx* dctx, int* nbSeqPtr,
	const void* src, size_t srcSize);


	#if defined (__cplusplus)
	}
	#endif

	#endif /* ZSTD_CCOMMON_H_MODULE */
	/** ended inlining zstd_internal.h **/
	/** start inlining pool.h **/
	/*
	* Copyright (c) 2016-2020, Yann Collet, Facebook, Inc.
	* All rights reserved.
	*
	* This source code is licensed under both the BSD-style license (found in the
	* LICENSE file in the root directory of this source tree) and the GPLv2 (found
	* in the COPYING file in the root directory of this source tree).
	* You may select, at your option, one of the above-listed licenses.
	*/

	#ifndef POOL_H
	#define POOL_H

	#if defined (__cplusplus)
	extern "C" {
	#endif


	#include <stddef.h> /* size_t */
	#define ZSTD_STATIC_LINKING_ONLY /* ZSTD_customMem */
	/** skipping file: ../zstd.h **/

	typedef struct POOL_ctx_s POOL_ctx;

	/*! POOL_create() :
	* Create a thread pool with at most `numThreads` threads.
	* `numThreads` must be at least 1.
	* The maximum number of queued jobs before blocking is `queueSize`.
	* @return : POOL_ctx pointer on success, else NULL.
	*/
	POOL_ctx* POOL_create(size_t numThreads, size_t queueSize);

	POOL_ctx* POOL_create_advanced(size_t numThreads, size_t queueSize,
	ZSTD_customMem customMem);

	/*! POOL_free() :
	* Free a thread pool returned by POOL_create().
	*/
	void POOL_free(POOL_ctx* ctx);

	/*! POOL_resize() :
	* Expands or shrinks pool's number of threads.
	* This is more efficient than releasing + creating a new context,
	* since it tries to preserve and re-use existing threads.
	* `numThreads` must be at least 1.
	* @return : 0 when resize was successful,
	* !0 (typically 1) if there is an error.
	* note : only numThreads can be resized, queueSize remains unchanged.
	*/
	int POOL_resize(POOL_ctx* ctx, size_t numThreads);

	/*! POOL_sizeof() :
	* @return threadpool memory usage
	* note : compatible with NULL (returns 0 in this case)
	*/
	size_t POOL_sizeof(POOL_ctx* ctx);

	/*! POOL_function :
	* The function type that can be added to a thread pool.
	*/
	typedef void (POOL_function)(void);

	/*! POOL_add() :
	* Add the job `function(opaque)` to the thread pool. `ctx` must be valid.
	* Possibly blocks until there is room in the queue.
	* Note : The function may be executed asynchronously,
	* therefore, `opaque` must live until function has been completed.
	*/
	void POOL_add(POOL_ctx* ctx, POOL_function function, void* opaque);


	/*! POOL_tryAdd() :
	* Add the job `function(opaque)` to thread pool _if_ a worker is available.
	* Returns immediately even if not (does not block).
	* @return : 1 if successful, 0 if not.
	*/
	int POOL_tryAdd(POOL_ctx* ctx, POOL_function function, void* opaque);


	#if defined (__cplusplus)
	}
	#endif

	#endif
	/** ended inlining pool.h **/

	/* ====== Compiler specifics ====== */
	#if defined(_MSC_VER)
	# pragma warning(disable : 4204) /* disable: C4204: non-constant aggregate initializer */
	#endif


	#ifdef ZSTD_MULTITHREAD

	/** start inlining threading.h **/
	/**
	* Copyright (c) 2016 Tino Reichardt
	* All rights reserved.
	*
	* You can contact the author at:
	* - zstdmt source repository: https://github.com/mcmilk/zstdmt
	*
	* This source code is licensed under both the BSD-style license (found in the
	* LICENSE file in the root directory of this source tree) and the GPLv2 (found
	* in the COPYING file in the root directory of this source tree).
	* You may select, at your option, one of the above-listed licenses.
	*/

	#ifndef THREADING_H_938743
	#define THREADING_H_938743

	/** skipping file: debug.h **/

	#if defined (__cplusplus)
	extern "C" {
	#endif

	#if defined(ZSTD_MULTITHREAD) && defined(_WIN32)

	/**
	* Windows minimalist Pthread Wrapper, based on :
	* http://www.cse.wustl.edu/~schmidt/win32-cv-1.html
	*/
	#ifdef WINVER
	# undef WINVER
	#endif
	#define WINVER 0x0600

	#ifdef _WIN32_WINNT
	# undef _WIN32_WINNT
	#endif
	#define _WIN32_WINNT 0x0600

	#ifndef WIN32_LEAN_AND_MEAN
	# define WIN32_LEAN_AND_MEAN
	#endif

	#undef ERROR /* reported already defined on VS 2015 (Rich Geldreich) */
	#include <windows.h>
	#undef ERROR
	#define ERROR(name) ZSTD_ERROR(name)


	/* mutex */
	#define ZSTD_pthread_mutex_t CRITICAL_SECTION
	#define ZSTD_pthread_mutex_init(a, b) ((void)(b), InitializeCriticalSection((a)), 0)
	#define ZSTD_pthread_mutex_destroy(a) DeleteCriticalSection((a))
	#define ZSTD_pthread_mutex_lock(a) EnterCriticalSection((a))
	#define ZSTD_pthread_mutex_unlock(a) LeaveCriticalSection((a))

	/* condition variable */
	#define ZSTD_pthread_cond_t CONDITION_VARIABLE
	#define ZSTD_pthread_cond_init(a, b) ((void)(b), InitializeConditionVariable((a)), 0)
	#define ZSTD_pthread_cond_destroy(a) ((void)(a))
	#define ZSTD_pthread_cond_wait(a, b) SleepConditionVariableCS((a), (b), INFINITE)
	#define ZSTD_pthread_cond_signal(a) WakeConditionVariable((a))
	#define ZSTD_pthread_cond_broadcast(a) WakeAllConditionVariable((a))

	/* ZSTD_pthread_create() and ZSTD_pthread_join() */
	typedef struct {
	HANDLE handle;
	void* (start_routine)(void);
	void* arg;
	} ZSTD_pthread_t;

	int ZSTD_pthread_create(ZSTD_pthread_t* thread, const void* unused,
	void* (start_routine) (void), void* arg);

	int ZSTD_pthread_join(ZSTD_pthread_t thread, void** value_ptr);

	/**
	* add here more wrappers as required
	*/


	#elif defined(ZSTD_MULTITHREAD) /* posix assumed ; need a better detection method */
	/* === POSIX Systems === */
	# include <pthread.h>

	#if DEBUGLEVEL < 1

	#define ZSTD_pthread_mutex_t pthread_mutex_t
	#define ZSTD_pthread_mutex_init(a, b) pthread_mutex_init((a), (b))
	#define ZSTD_pthread_mutex_destroy(a) pthread_mutex_destroy((a))
	#define ZSTD_pthread_mutex_lock(a) pthread_mutex_lock((a))
	#define ZSTD_pthread_mutex_unlock(a) pthread_mutex_unlock((a))

	#define ZSTD_pthread_cond_t pthread_cond_t
	#define ZSTD_pthread_cond_init(a, b) pthread_cond_init((a), (b))
	#define ZSTD_pthread_cond_destroy(a) pthread_cond_destroy((a))
	#define ZSTD_pthread_cond_wait(a, b) pthread_cond_wait((a), (b))
	#define ZSTD_pthread_cond_signal(a) pthread_cond_signal((a))
	#define ZSTD_pthread_cond_broadcast(a) pthread_cond_broadcast((a))

	#define ZSTD_pthread_t pthread_t
	#define ZSTD_pthread_create(a, b, c, d) pthread_create((a), (b), (c), (d))
	#define ZSTD_pthread_join(a, b) pthread_join((a),(b))

	#else /* DEBUGLEVEL >= 1 */

	/* Debug implementation of threading.
	* In this implementation we use pointers for mutexes and condition variables.
	* This way, if we forget to init/destroy them the program will crash or ASAN
	* will report leaks.
	*/

	#define ZSTD_pthread_mutex_t pthread_mutex_t*
	int ZSTD_pthread_mutex_init(ZSTD_pthread_mutex_t* mutex, pthread_mutexattr_t const* attr);
	int ZSTD_pthread_mutex_destroy(ZSTD_pthread_mutex_t* mutex);
	#define ZSTD_pthread_mutex_lock(a) pthread_mutex_lock(*(a))
	#define ZSTD_pthread_mutex_unlock(a) pthread_mutex_unlock(*(a))

	#define ZSTD_pthread_cond_t pthread_cond_t*
	int ZSTD_pthread_cond_init(ZSTD_pthread_cond_t* cond, pthread_condattr_t const* attr);
	int ZSTD_pthread_cond_destroy(ZSTD_pthread_cond_t* cond);
	#define ZSTD_pthread_cond_wait(a, b) pthread_cond_wait((a), (b))
	#define ZSTD_pthread_cond_signal(a) pthread_cond_signal(*(a))
	#define ZSTD_pthread_cond_broadcast(a) pthread_cond_broadcast(*(a))

	#define ZSTD_pthread_t pthread_t
	#define ZSTD_pthread_create(a, b, c, d) pthread_create((a), (b), (c), (d))
	#define ZSTD_pthread_join(a, b) pthread_join((a),(b))

	#endif

	#else /* ZSTD_MULTITHREAD not defined */
	/* No multithreading support */

	typedef int ZSTD_pthread_mutex_t;
	#define ZSTD_pthread_mutex_init(a, b) ((void)(a), (void)(b), 0)
	#define ZSTD_pthread_mutex_destroy(a) ((void)(a))
	#define ZSTD_pthread_mutex_lock(a) ((void)(a))
	#define ZSTD_pthread_mutex_unlock(a) ((void)(a))

	typedef int ZSTD_pthread_cond_t;
	#define ZSTD_pthread_cond_init(a, b) ((void)(a), (void)(b), 0)
	#define ZSTD_pthread_cond_destroy(a) ((void)(a))
	#define ZSTD_pthread_cond_wait(a, b) ((void)(a), (void)(b))
	#define ZSTD_pthread_cond_signal(a) ((void)(a))
	#define ZSTD_pthread_cond_broadcast(a) ((void)(a))

	/* do not use ZSTD_pthread_t */

	#endif /* ZSTD_MULTITHREAD */

	#if defined (__cplusplus)
	}
	#endif

	#endif /* THREADING_H_938743 */
	/** ended inlining threading.h **/

	/* A job is a function and an opaque argument */
	typedef struct POOL_job_s {
	POOL_function function;
	void *opaque;
	} POOL_job;

	struct POOL_ctx_s {
	ZSTD_customMem customMem;
	/* Keep track of the threads */
	ZSTD_pthread_t* threads;
	size_t threadCapacity;
	size_t threadLimit;

	/* The queue is a circular buffer */
	POOL_job *queue;
	size_t queueHead;
	size_t queueTail;
	size_t queueSize;

	/* The number of threads working on jobs */
	size_t numThreadsBusy;
	/* Indicates if the queue is empty */
	int queueEmpty;

	/* The mutex protects the queue */
	ZSTD_pthread_mutex_t queueMutex;
	/* Condition variable for pushers to wait on when the queue is full */
	ZSTD_pthread_cond_t queuePushCond;
	/* Condition variables for poppers to wait on when the queue is empty */
	ZSTD_pthread_cond_t queuePopCond;
	/* Indicates if the queue is shutting down */
	int shutdown;
	};

	/* POOL_thread() :
	* Work thread for the thread pool.
	* Waits for jobs and executes them.
	* @returns : NULL on failure else non-null.
	*/
	static void* POOL_thread(void* opaque) {
	POOL_ctx* const ctx = (POOL_ctx*)opaque;
	if (!ctx) { return NULL; }
	for (;;) {
	/* Lock the mutex and wait for a non-empty queue or until shutdown */
	ZSTD_pthread_mutex_lock(&ctx->queueMutex);

	while ( ctx->queueEmpty
	\|\| (ctx->numThreadsBusy >= ctx->threadLimit) ) {
	if (ctx->shutdown) {
	/* even if !queueEmpty, (possible if numThreadsBusy >= threadLimit),
	* a few threads will be shutdown while !queueEmpty,
	* but enough threads will remain active to finish the queue */
	ZSTD_pthread_mutex_unlock(&ctx->queueMutex);
	return opaque;
	}
	ZSTD_pthread_cond_wait(&ctx->queuePopCond, &ctx->queueMutex);
	}
	/* Pop a job off the queue */
	{ POOL_job const job = ctx->queue[ctx->queueHead];
	ctx->queueHead = (ctx->queueHead + 1) % ctx->queueSize;
	ctx->numThreadsBusy++;
	ctx->queueEmpty = ctx->queueHead == ctx->queueTail;
	/* Unlock the mutex, signal a pusher, and run the job */
	ZSTD_pthread_cond_signal(&ctx->queuePushCond);
	ZSTD_pthread_mutex_unlock(&ctx->queueMutex);

	job.function(job.opaque);

	/* If the intended queue size was 0, signal after finishing job */
	ZSTD_pthread_mutex_lock(&ctx->queueMutex);
	ctx->numThreadsBusy--;
	if (ctx->queueSize == 1) {
	ZSTD_pthread_cond_signal(&ctx->queuePushCond);
	}
	ZSTD_pthread_mutex_unlock(&ctx->queueMutex);
	}
	} /* for (;;) */
	assert(0); /* Unreachable */
	}

	POOL_ctx* POOL_create(size_t numThreads, size_t queueSize) {
	return POOL_create_advanced(numThreads, queueSize, ZSTD_defaultCMem);
	}

	POOL_ctx* POOL_create_advanced(size_t numThreads, size_t queueSize,
	ZSTD_customMem customMem) {
	POOL_ctx* ctx;
	/* Check parameters */
	if (!numThreads) { return NULL; }
	/* Allocate the context and zero initialize */
	ctx = (POOL_ctx*)ZSTD_calloc(sizeof(POOL_ctx), customMem);
	if (!ctx) { return NULL; }
	/* Initialize the job queue.
	* It needs one extra space since one space is wasted to differentiate
	* empty and full queues.
	*/
	ctx->queueSize = queueSize + 1;
	ctx->queue = (POOL_job)ZSTD_malloc(ctx->queueSize sizeof(POOL_job), customMem);
	ctx->queueHead = 0;
	ctx->queueTail = 0;
	ctx->numThreadsBusy = 0;
	ctx->queueEmpty = 1;
	{
	int error = 0;
	error \|= ZSTD_pthread_mutex_init(&ctx->queueMutex, NULL);
	error \|= ZSTD_pthread_cond_init(&ctx->queuePushCond, NULL);
	error \|= ZSTD_pthread_cond_init(&ctx->queuePopCond, NULL);
	if (error) { POOL_free(ctx); return NULL; }
	}
	ctx->shutdown = 0;
	/* Allocate space for the thread handles */
	ctx->threads = (ZSTD_pthread_t)ZSTD_malloc(numThreads sizeof(ZSTD_pthread_t), customMem);
	ctx->threadCapacity = 0;
	ctx->customMem = customMem;
	/* Check for errors */
	if (!ctx->threads \|\| !ctx->queue) { POOL_free(ctx); return NULL; }
	/* Initialize the threads */
	{ size_t i;
	for (i = 0; i < numThreads; ++i) {
	if (ZSTD_pthread_create(&ctx->threads[i], NULL, &POOL_thread, ctx)) {
	ctx->threadCapacity = i;
	POOL_free(ctx);
	return NULL;
	} }
	ctx->threadCapacity = numThreads;
	ctx->threadLimit = numThreads;
	}
	return ctx;
	}

	/*! POOL_join() :
	Shutdown the queue, wake any sleeping threads, and join all of the threads.
	*/
	static void POOL_join(POOL_ctx* ctx) {
	/* Shut down the queue */
	ZSTD_pthread_mutex_lock(&ctx->queueMutex);
	ctx->shutdown = 1;
	ZSTD_pthread_mutex_unlock(&ctx->queueMutex);
	/* Wake up sleeping threads */
	ZSTD_pthread_cond_broadcast(&ctx->queuePushCond);
	ZSTD_pthread_cond_broadcast(&ctx->queuePopCond);
	/* Join all of the threads */
	{ size_t i;
	for (i = 0; i < ctx->threadCapacity; ++i) {
	ZSTD_pthread_join(ctx->threads[i], NULL); /* note : could fail */
	} }
	}

	void POOL_free(POOL_ctx *ctx) {
	if (!ctx) { return; }
	POOL_join(ctx);
	ZSTD_pthread_mutex_destroy(&ctx->queueMutex);
	ZSTD_pthread_cond_destroy(&ctx->queuePushCond);
	ZSTD_pthread_cond_destroy(&ctx->queuePopCond);
	ZSTD_free(ctx->queue, ctx->customMem);
	ZSTD_free(ctx->threads, ctx->customMem);
	ZSTD_free(ctx, ctx->customMem);
	}



	size_t POOL_sizeof(POOL_ctx *ctx) {
	if (ctx==NULL) return 0; /* supports sizeof NULL */
	return sizeof(*ctx)
	+ ctx->queueSize * sizeof(POOL_job)
	+ ctx->threadCapacity * sizeof(ZSTD_pthread_t);
	}


	/* @return : 0 on success, 1 on error */
	static int POOL_resize_internal(POOL_ctx* ctx, size_t numThreads)
	{
	if (numThreads <= ctx->threadCapacity) {
	if (!numThreads) return 1;
	ctx->threadLimit = numThreads;
	return 0;
	}
	/* numThreads > threadCapacity */
	{ ZSTD_pthread_t* const threadPool = (ZSTD_pthread_t)ZSTD_malloc(numThreads sizeof(ZSTD_pthread_t), ctx->customMem);
	if (!threadPool) return 1;
	/* replace existing thread pool */
	memcpy(threadPool, ctx->threads, ctx->threadCapacity * sizeof(*threadPool));
	ZSTD_free(ctx->threads, ctx->customMem);
	ctx->threads = threadPool;
	/* Initialize additional threads */
	{ size_t threadId;
	for (threadId = ctx->threadCapacity; threadId < numThreads; ++threadId) {
	if (ZSTD_pthread_create(&threadPool[threadId], NULL, &POOL_thread, ctx)) {
	ctx->threadCapacity = threadId;
	return 1;
	} }
	} }
	/* successfully expanded */
	ctx->threadCapacity = numThreads;
	ctx->threadLimit = numThreads;
	return 0;
	}

	/* @return : 0 on success, 1 on error */
	int POOL_resize(POOL_ctx* ctx, size_t numThreads)
	{
	int result;
	if (ctx==NULL) return 1;
	ZSTD_pthread_mutex_lock(&ctx->queueMutex);
	result = POOL_resize_internal(ctx, numThreads);
	ZSTD_pthread_cond_broadcast(&ctx->queuePopCond);
	ZSTD_pthread_mutex_unlock(&ctx->queueMutex);
	return result;
	}

	/**
	* Returns 1 if the queue is full and 0 otherwise.
	*
	* When queueSize is 1 (pool was created with an intended queueSize of 0),
	* then a queue is empty if there is a thread free _and_ no job is waiting.
	*/
	static int isQueueFull(POOL_ctx const* ctx) {
	if (ctx->queueSize > 1) {
	return ctx->queueHead == ((ctx->queueTail + 1) % ctx->queueSize);
	} else {
	return (ctx->numThreadsBusy == ctx->threadLimit) \|\|
	!ctx->queueEmpty;
	}
	}


	static void POOL_add_internal(POOL_ctx* ctx, POOL_function function, void *opaque)
	{
	POOL_job const job = {function, opaque};
	assert(ctx != NULL);
	if (ctx->shutdown) return;

	ctx->queueEmpty = 0;
	ctx->queue[ctx->queueTail] = job;
	ctx->queueTail = (ctx->queueTail + 1) % ctx->queueSize;
	ZSTD_pthread_cond_signal(&ctx->queuePopCond);
	}

	void POOL_add(POOL_ctx* ctx, POOL_function function, void* opaque)
	{
	assert(ctx != NULL);
	ZSTD_pthread_mutex_lock(&ctx->queueMutex);
	/* Wait until there is space in the queue for the new job */
	while (isQueueFull(ctx) && (!ctx->shutdown)) {
	ZSTD_pthread_cond_wait(&ctx->queuePushCond, &ctx->queueMutex);
	}
	POOL_add_internal(ctx, function, opaque);
	ZSTD_pthread_mutex_unlock(&ctx->queueMutex);
	}


	int POOL_tryAdd(POOL_ctx* ctx, POOL_function function, void* opaque)
	{
	assert(ctx != NULL);
	ZSTD_pthread_mutex_lock(&ctx->queueMutex);
	if (isQueueFull(ctx)) {
	ZSTD_pthread_mutex_unlock(&ctx->queueMutex);
	return 0;
	}
	POOL_add_internal(ctx, function, opaque);
	ZSTD_pthread_mutex_unlock(&ctx->queueMutex);
	return 1;
	}


	#else /* ZSTD_MULTITHREAD not defined */

	/* ========================== */
	/* No multi-threading support */
	/* ========================== */


	/* We don't need any data, but if it is empty, malloc() might return NULL. */
	struct POOL_ctx_s {
	int dummy;
	};
	static POOL_ctx g_ctx;

	POOL_ctx* POOL_create(size_t numThreads, size_t queueSize) {
	return POOL_create_advanced(numThreads, queueSize, ZSTD_defaultCMem);
	}

	POOL_ctx* POOL_create_advanced(size_t numThreads, size_t queueSize, ZSTD_customMem customMem) {
	(void)numThreads;
	(void)queueSize;
	(void)customMem;
	return &g_ctx;
	}

	void POOL_free(POOL_ctx* ctx) {
	assert(!ctx \|\| ctx == &g_ctx);
	(void)ctx;
	}

	int POOL_resize(POOL_ctx* ctx, size_t numThreads) {
	(void)ctx; (void)numThreads;
	return 0;
	}

	void POOL_add(POOL_ctx* ctx, POOL_function function, void* opaque) {
	(void)ctx;
	function(opaque);
	}

	int POOL_tryAdd(POOL_ctx* ctx, POOL_function function, void* opaque) {
	(void)ctx;
	function(opaque);
	return 1;
	}

	size_t POOL_sizeof(POOL_ctx* ctx) {
	if (ctx==NULL) return 0; /* supports sizeof NULL */
	assert(ctx == &g_ctx);
	return sizeof(*ctx);
	}

	#endif /* ZSTD_MULTITHREAD */
	/** ended inlining common/pool.c **/
	/** start inlining common/zstd_common.c **/
	/*
	* Copyright (c) 2016-2020, Yann Collet, Facebook, Inc.
	* All rights reserved.
	*
	* This source code is licensed under both the BSD-style license (found in the
	* LICENSE file in the root directory of this source tree) and the GPLv2 (found
	* in the COPYING file in the root directory of this source tree).
	* You may select, at your option, one of the above-listed licenses.
	*/



	/-************************************
	* Dependencies
	***************************************/
	#include <stdlib.h> /* malloc, calloc, free */
	#include <string.h> /* memset */
	/** skipping file: error_private.h **/
	/** skipping file: zstd_internal.h **/


	/-***************************************
	* Version
	******************************************/
	unsigned ZSTD_versionNumber(void) { return ZSTD_VERSION_NUMBER; }

	const char* ZSTD_versionString(void) { return ZSTD_VERSION_STRING; }


	/-***************************************
	* ZSTD Error Management
	******************************************/
	-#undef ZSTD_isError /* defined within zstd_internal.h */
	/*! ZSTD_isError() :
	* tells if a return value is an error code
	* symbol is required for external callers */
	unsigned ZSTD_isError(size_t code) { return ERR_isError(code); }

	/*! ZSTD_getErrorName() :
	* provides error code string from function result (useful for debugging) */
	const char* ZSTD_getErrorName(size_t code) { return ERR_getErrorName(code); }

	/*! ZSTD_getError() :
	* convert a `size_t` function result into a proper ZSTD_errorCode enum */
	ZSTD_ErrorCode ZSTD_getErrorCode(size_t code) { return ERR_getErrorCode(code); }

	/*! ZSTD_getErrorString() :
	* provides error code string from enum */
	const char* ZSTD_getErrorString(ZSTD_ErrorCode code) { return ERR_getErrorString(code); }



	/=*************************************************************
	* Custom allocator
	****************************************************************/
	void* ZSTD_malloc(size_t size, ZSTD_customMem customMem)
	{
	if (customMem.customAlloc)
	return customMem.customAlloc(customMem.opaque, size);
	return malloc(size);
	}

	void* ZSTD_calloc(size_t size, ZSTD_customMem customMem)
	{
	if (customMem.customAlloc) {
	/* calloc implemented as malloc+memset;
	* not as efficient as calloc, but next best guess for custom malloc */
	void* const ptr = customMem.customAlloc(customMem.opaque, size);
	memset(ptr, 0, size);
	return ptr;
	}
	return calloc(1, size);
	}

	void ZSTD_free(void* ptr, ZSTD_customMem customMem)
	{
	if (ptr!=NULL) {
	if (customMem.customFree)
	customMem.customFree(customMem.opaque, ptr);
	else
	free(ptr);
	}
	}
	/** ended inlining common/zstd_common.c **/

	/** start inlining compress/fse_compress.c **/
	/* ******************************************************************
	* FSE : Finite State Entropy encoder
	* Copyright (c) 2013-2020, Yann Collet, Facebook, Inc.
	*
	* You can contact the author at :
	* - FSE source repository : https://github.com/Cyan4973/FiniteStateEntropy
	* - Public forum : https://groups.google.com/forum/#!forum/lz4c
	*
	* This source code is licensed under both the BSD-style license (found in the
	* LICENSE file in the root directory of this source tree) and the GPLv2 (found
	* in the COPYING file in the root directory of this source tree).
	* You may select, at your option, one of the above-listed licenses.
	****************************************************************** */

	/* **************************************************************
	* Includes
	****************************************************************/
	#include <stdlib.h> /* malloc, free, qsort */
	#include <string.h> /* memcpy, memset */
	/** skipping file: ../common/compiler.h **/
	/** skipping file: ../common/mem.h **/
	/** skipping file: ../common/debug.h **/
	/** start inlining hist.h **/
	/* ******************************************************************
	* hist : Histogram functions
	* part of Finite State Entropy project
	* Copyright (c) 2013-2020, Yann Collet, Facebook, Inc.
	*
	* You can contact the author at :
	* - FSE source repository : https://github.com/Cyan4973/FiniteStateEntropy
	* - Public forum : https://groups.google.com/forum/#!forum/lz4c
	*
	* This source code is licensed under both the BSD-style license (found in the
	* LICENSE file in the root directory of this source tree) and the GPLv2 (found
	* in the COPYING file in the root directory of this source tree).
	* You may select, at your option, one of the above-listed licenses.
	****************************************************************** */

	/* --- dependencies --- */
	#include <stddef.h> /* size_t */


	/* --- simple histogram functions --- */

	/*! HIST_count():
	* Provides the precise count of each byte within a table 'count'.
	* 'count' is a table of unsigned int, of minimum size (*maxSymbolValuePtr+1).
	* Updates *maxSymbolValuePtr with actual largest symbol value detected.
	* @return : count of the most frequent symbol (which isn't identified).
	* or an error code, which can be tested using HIST_isError().
	* note : if return == srcSize, there is only one symbol.
	*/
	size_t HIST_count(unsigned* count, unsigned* maxSymbolValuePtr,
	const void* src, size_t srcSize);

	unsigned HIST_isError(size_t code); /*< tells if a return value is an error code /


	/* --- advanced histogram functions --- */

	#define HIST_WKSP_SIZE_U32 1024
	#define HIST_WKSP_SIZE (HIST_WKSP_SIZE_U32 * sizeof(unsigned))
	/** HIST_count_wksp() :
	* Same as HIST_count(), but using an externally provided scratch buffer.
	* Benefit is this function will use very little stack space.
	* `workSpace` is a writable buffer which must be 4-bytes aligned,
	* `workSpaceSize` must be >= HIST_WKSP_SIZE
	*/
	size_t HIST_count_wksp(unsigned* count, unsigned* maxSymbolValuePtr,
	const void* src, size_t srcSize,
	void* workSpace, size_t workSpaceSize);

	/** HIST_countFast() :
	* same as HIST_count(), but blindly trusts that all byte values within src are <= *maxSymbolValuePtr.
	* This function is unsafe, and will segfault if any value within `src` is `> *maxSymbolValuePtr`
	*/
	size_t HIST_countFast(unsigned* count, unsigned* maxSymbolValuePtr,
	const void* src, size_t srcSize);

	/** HIST_countFast_wksp() :
	* Same as HIST_countFast(), but using an externally provided scratch buffer.
	* `workSpace` is a writable buffer which must be 4-bytes aligned,
	* `workSpaceSize` must be >= HIST_WKSP_SIZE
	*/
	size_t HIST_countFast_wksp(unsigned* count, unsigned* maxSymbolValuePtr,
	const void* src, size_t srcSize,
	void* workSpace, size_t workSpaceSize);

	/*! HIST_count_simple() :
	* Same as HIST_countFast(), this function is unsafe,
	* and will segfault if any value within `src` is `> *maxSymbolValuePtr`.
	* It is also a bit slower for large inputs.
	* However, it does not need any additional memory (not even on stack).
	* @return : count of the most frequent symbol.
	* Note this function doesn't produce any error (i.e. it must succeed).
	*/
	unsigned HIST_count_simple(unsigned* count, unsigned* maxSymbolValuePtr,
	const void* src, size_t srcSize);
	/** ended inlining hist.h **/
	/** skipping file: ../common/bitstream.h **/
	#define FSE_STATIC_LINKING_ONLY
	/** skipping file: ../common/fse.h **/
	/** skipping file: ../common/error_private.h **/


	/* **************************************************************
	* Error Management
	****************************************************************/
	#define FSE_isError ERR_isError


	/* **************************************************************
	* Templates
	****************************************************************/
	/*
	designed to be included
	for type-specific functions (template emulation in C)
	Objective is to write these functions only once, for improved maintenance
	*/

	/* safety checks */
	#ifndef FSE_FUNCTION_EXTENSION
	# error "FSE_FUNCTION_EXTENSION must be defined"
	#endif
	#ifndef FSE_FUNCTION_TYPE
	# error "FSE_FUNCTION_TYPE must be defined"
	#endif

	/* Function names */
	#define FSE_CAT(X,Y) X##Y
	#define FSE_FUNCTION_NAME(X,Y) FSE_CAT(X,Y)
	#define FSE_TYPE_NAME(X,Y) FSE_CAT(X,Y)


	/* Function templates */

	/* FSE_buildCTable_wksp() :
	* Same as FSE_buildCTable(), but using an externally allocated scratch buffer (`workSpace`).
	* wkspSize should be sized to handle worst case situation, which is `1<<max_tableLog * sizeof(FSE_FUNCTION_TYPE)`
	* workSpace must also be properly aligned with FSE_FUNCTION_TYPE requirements
	*/
	size_t FSE_buildCTable_wksp(FSE_CTable* ct,
	const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog,
	void* workSpace, size_t wkspSize)
	{
	U32 const tableSize = 1 << tableLog;
	U32 const tableMask = tableSize - 1;
	void* const ptr = ct;
	U16* const tableU16 = ( (U16*) ptr) + 2;
	void* const FSCT = ((U32)ptr) + 1 / header */ + (tableLog ? tableSize>>1 : 1) ;
	FSE_symbolCompressionTransform* const symbolTT = (FSE_symbolCompressionTransform*) (FSCT);
	U32 const step = FSE_TABLESTEP(tableSize);
	U32 cumul[FSE_MAX_SYMBOL_VALUE+2];

	FSE_FUNCTION_TYPE* const tableSymbol = (FSE_FUNCTION_TYPE*)workSpace;
	U32 highThreshold = tableSize-1;

	/* CTable header */
	if (((size_t)1 << tableLog) * sizeof(FSE_FUNCTION_TYPE) > wkspSize) return ERROR(tableLog_tooLarge);
	tableU16[-2] = (U16) tableLog;
	tableU16[-1] = (U16) maxSymbolValue;
	assert(tableLog < 16); /* required for threshold strategy to work */

	/* For explanations on how to distribute symbol values over the table :
	* http://fastcompression.blogspot.fr/2014/02/fse-distributing-symbol-values.html */

	#ifdef __clang_analyzer__
	memset(tableSymbol, 0, sizeof(tableSymbol) tableSize); /* useless initialization, just to keep scan-build happy */
	#endif

	/* symbol start positions */
	{ U32 u;
	cumul[0] = 0;
	for (u=1; u <= maxSymbolValue+1; u++) {
	if (normalizedCounter[u-1]==-1) { /* Low proba symbol */
	cumul[u] = cumul[u-1] + 1;
	tableSymbol[highThreshold--] = (FSE_FUNCTION_TYPE)(u-1);
	} else {
	cumul[u] = cumul[u-1] + normalizedCounter[u-1];
	} }
	cumul[maxSymbolValue+1] = tableSize+1;
	}

	/* Spread symbols */
	{ U32 position = 0;
	U32 symbol;
	for (symbol=0; symbol<=maxSymbolValue; symbol++) {
	int nbOccurrences;
	int const freq = normalizedCounter[symbol];
	for (nbOccurrences=0; nbOccurrences<freq; nbOccurrences++) {
	tableSymbol[position] = (FSE_FUNCTION_TYPE)symbol;
	position = (position + step) & tableMask;
	while (position > highThreshold)
	position = (position + step) & tableMask; /* Low proba area */
	} }

	assert(position==0); /* Must have initialized all positions */
	}

	/* Build table */
	{ U32 u; for (u=0; u<tableSize; u++) {
	FSE_FUNCTION_TYPE s = tableSymbol[u]; /* note : static analyzer may not understand tableSymbol is properly initialized */
	tableU16[cumul[s]++] = (U16) (tableSize+u); /* TableU16 : sorted by symbol order; gives next state value */
	} }

	/* Build Symbol Transformation Table */
	{ unsigned total = 0;
	unsigned s;
	for (s=0; s<=maxSymbolValue; s++) {
	switch (normalizedCounter[s])
	{
	case 0:
	/* filling nonetheless, for compatibility with FSE_getMaxNbBits() */
	symbolTT[s].deltaNbBits = ((tableLog+1) << 16) - (1<<tableLog);
	break;

	case -1:
	case 1:
	symbolTT[s].deltaNbBits = (tableLog << 16) - (1<<tableLog);
	symbolTT[s].deltaFindState = total - 1;
	total ++;
	break;
	default :
	{
	U32 const maxBitsOut = tableLog - BIT_highbit32 (normalizedCounter[s]-1);
	U32 const minStatePlus = normalizedCounter[s] << maxBitsOut;
	symbolTT[s].deltaNbBits = (maxBitsOut << 16) - minStatePlus;
	symbolTT[s].deltaFindState = total - normalizedCounter[s];
	total += normalizedCounter[s];
	} } } }

	#if 0 /* debug : symbol costs */
	DEBUGLOG(5, "\n --- table statistics : ");
	{ U32 symbol;
	for (symbol=0; symbol<=maxSymbolValue; symbol++) {
	DEBUGLOG(5, "%3u: w=%3i, maxBits=%u, fracBits=%.2f",
	symbol, normalizedCounter[symbol],
	FSE_getMaxNbBits(symbolTT, symbol),
	(double)FSE_bitCost(symbolTT, tableLog, symbol, 8) / 256);
	}
	}
	#endif

	return 0;
	}


	size_t FSE_buildCTable(FSE_CTable* ct, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog)
	{
	FSE_FUNCTION_TYPE tableSymbol[FSE_MAX_TABLESIZE]; /* memset() is not necessary, even if static analyzer complain about it */
	return FSE_buildCTable_wksp(ct, normalizedCounter, maxSymbolValue, tableLog, tableSymbol, sizeof(tableSymbol));
	}



	#ifndef FSE_COMMONDEFS_ONLY


	/-*************************************************************
	* FSE NCount encoding
	****************************************************************/
	size_t FSE_NCountWriteBound(unsigned maxSymbolValue, unsigned tableLog)
	{
	size_t const maxHeaderSize = (((maxSymbolValue+1) * tableLog) >> 3) + 3;
	return maxSymbolValue ? maxHeaderSize : FSE_NCOUNTBOUND; /* maxSymbolValue==0 ? use default */
	}

	static size_t
	FSE_writeNCount_generic (void* header, size_t headerBufferSize,
	const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog,
	unsigned writeIsSafe)
	{
	BYTE* const ostart = (BYTE*) header;
	BYTE* out = ostart;
	BYTE* const oend = ostart + headerBufferSize;
	int nbBits;
	const int tableSize = 1 << tableLog;
	int remaining;
	int threshold;
	U32 bitStream = 0;
	int bitCount = 0;
	unsigned symbol = 0;
	unsigned const alphabetSize = maxSymbolValue + 1;
	int previousIs0 = 0;

	/* Table Size */
	bitStream += (tableLog-FSE_MIN_TABLELOG) << bitCount;
	bitCount += 4;

	/* Init */
	remaining = tableSize+1; /* +1 for extra accuracy */
	threshold = tableSize;
	nbBits = tableLog+1;

	while ((symbol < alphabetSize) && (remaining>1)) { /* stops at 1 */
	if (previousIs0) {
	unsigned start = symbol;
	while ((symbol < alphabetSize) && !normalizedCounter[symbol]) symbol++;
	if (symbol == alphabetSize) break; /* incorrect distribution */
	while (symbol >= start+24) {
	start+=24;
	bitStream += 0xFFFFU << bitCount;
	if ((!writeIsSafe) && (out > oend-2))
	return ERROR(dstSize_tooSmall); /* Buffer overflow */
	out[0] = (BYTE) bitStream;
	out[1] = (BYTE)(bitStream>>8);
	out+=2;
	bitStream>>=16;
	}
	while (symbol >= start+3) {
	start+=3;
	bitStream += 3 << bitCount;
	bitCount += 2;
	}
	bitStream += (symbol-start) << bitCount;
	bitCount += 2;
	if (bitCount>16) {
	if ((!writeIsSafe) && (out > oend - 2))
	return ERROR(dstSize_tooSmall); /* Buffer overflow */
	out[0] = (BYTE)bitStream;
	out[1] = (BYTE)(bitStream>>8);
	out += 2;
	bitStream >>= 16;
	bitCount -= 16;
	} }
	{ int count = normalizedCounter[symbol++];
	int const max = (2*threshold-1) - remaining;
	remaining -= count < 0 ? -count : count;
	count++; /* +1 for extra accuracy */
	if (count>=threshold)
	count += max; /* [0..max[ [max..threshold[ (...) [threshold+max 2threshold[ /
	bitStream += count << bitCount;
	bitCount += nbBits;
	bitCount -= (count<max);
	previousIs0 = (count==1);
	if (remaining<1) return ERROR(GENERIC);
	while (remaining<threshold) { nbBits--; threshold>>=1; }
	}
	if (bitCount>16) {
	if ((!writeIsSafe) && (out > oend - 2))
	return ERROR(dstSize_tooSmall); /* Buffer overflow */
	out[0] = (BYTE)bitStream;
	out[1] = (BYTE)(bitStream>>8);
	out += 2;
	bitStream >>= 16;
	bitCount -= 16;
	} }

	if (remaining != 1)
	return ERROR(GENERIC); /* incorrect normalized distribution */
	assert(symbol <= alphabetSize);

	/* flush remaining bitStream */
	if ((!writeIsSafe) && (out > oend - 2))
	return ERROR(dstSize_tooSmall); /* Buffer overflow */
	out[0] = (BYTE)bitStream;
	out[1] = (BYTE)(bitStream>>8);
	out+= (bitCount+7) /8;

	return (out-ostart);
	}


	size_t FSE_writeNCount (void* buffer, size_t bufferSize,
	const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog)
	{
	if (tableLog > FSE_MAX_TABLELOG) return ERROR(tableLog_tooLarge); /* Unsupported */
	if (tableLog < FSE_MIN_TABLELOG) return ERROR(GENERIC); /* Unsupported */

	if (bufferSize < FSE_NCountWriteBound(maxSymbolValue, tableLog))
	return FSE_writeNCount_generic(buffer, bufferSize, normalizedCounter, maxSymbolValue, tableLog, 0);

	return FSE_writeNCount_generic(buffer, bufferSize, normalizedCounter, maxSymbolValue, tableLog, 1 /* write in buffer is safe */);
	}


	/-*************************************************************
	* FSE Compression Code
	****************************************************************/

	FSE_CTable* FSE_createCTable (unsigned maxSymbolValue, unsigned tableLog)
	{
	size_t size;
	if (tableLog > FSE_TABLELOG_ABSOLUTE_MAX) tableLog = FSE_TABLELOG_ABSOLUTE_MAX;
	size = FSE_CTABLE_SIZE_U32 (tableLog, maxSymbolValue) * sizeof(U32);
	return (FSE_CTable*)malloc(size);
	}

	void FSE_freeCTable (FSE_CTable* ct) { free(ct); }

	/* provides the minimum logSize to safely represent a distribution */
	static unsigned FSE_minTableLog(size_t srcSize, unsigned maxSymbolValue)
	{
	U32 minBitsSrc = BIT_highbit32((U32)(srcSize)) + 1;
	U32 minBitsSymbols = BIT_highbit32(maxSymbolValue) + 2;
	U32 minBits = minBitsSrc < minBitsSymbols ? minBitsSrc : minBitsSymbols;
	assert(srcSize > 1); /* Not supported, RLE should be used instead */
	return minBits;
	}

	unsigned FSE_optimalTableLog_internal(unsigned maxTableLog, size_t srcSize, unsigned maxSymbolValue, unsigned minus)
	{
	U32 maxBitsSrc = BIT_highbit32((U32)(srcSize - 1)) - minus;
	U32 tableLog = maxTableLog;
	U32 minBits = FSE_minTableLog(srcSize, maxSymbolValue);
	assert(srcSize > 1); /* Not supported, RLE should be used instead */
	if (tableLog==0) tableLog = FSE_DEFAULT_TABLELOG;
	if (maxBitsSrc < tableLog) tableLog = maxBitsSrc; /* Accuracy can be reduced */
	if (minBits > tableLog) tableLog = minBits; /* Need a minimum to safely represent all symbol values */
	if (tableLog < FSE_MIN_TABLELOG) tableLog = FSE_MIN_TABLELOG;
	if (tableLog > FSE_MAX_TABLELOG) tableLog = FSE_MAX_TABLELOG;
	return tableLog;
	}

	unsigned FSE_optimalTableLog(unsigned maxTableLog, size_t srcSize, unsigned maxSymbolValue)
	{
	return FSE_optimalTableLog_internal(maxTableLog, srcSize, maxSymbolValue, 2);
	}


	/* Secondary normalization method.
	To be used when primary method fails. */

	static size_t FSE_normalizeM2(short* norm, U32 tableLog, const unsigned* count, size_t total, U32 maxSymbolValue)
	{
	short const NOT_YET_ASSIGNED = -2;
	U32 s;
	U32 distributed = 0;
	U32 ToDistribute;

	/* Init */
	U32 const lowThreshold = (U32)(total >> tableLog);
	U32 lowOne = (U32)((total * 3) >> (tableLog + 1));

	for (s=0; s<=maxSymbolValue; s++) {
	if (count[s] == 0) {
	norm[s]=0;
	continue;
	}
	if (count[s] <= lowThreshold) {
	norm[s] = -1;
	distributed++;
	total -= count[s];
	continue;
	}
	if (count[s] <= lowOne) {
	norm[s] = 1;
	distributed++;
	total -= count[s];
	continue;
	}

	norm[s]=NOT_YET_ASSIGNED;
	}
	ToDistribute = (1 << tableLog) - distributed;

	if (ToDistribute == 0)
	return 0;

	if ((total / ToDistribute) > lowOne) {
	/* risk of rounding to zero */
	lowOne = (U32)((total * 3) / (ToDistribute * 2));
	for (s=0; s<=maxSymbolValue; s++) {
	if ((norm[s] == NOT_YET_ASSIGNED) && (count[s] <= lowOne)) {
	norm[s] = 1;
	distributed++;
	total -= count[s];
	continue;
	} }
	ToDistribute = (1 << tableLog) - distributed;
	}

	if (distributed == maxSymbolValue+1) {
	/* all values are pretty poor;
	probably incompressible data (should have already been detected);
	find max, then give all remaining points to max */
	U32 maxV = 0, maxC = 0;
	for (s=0; s<=maxSymbolValue; s++)
	if (count[s] > maxC) { maxV=s; maxC=count[s]; }
	norm[maxV] += (short)ToDistribute;
	return 0;
	}

	if (total == 0) {
	/* all of the symbols were low enough for the lowOne or lowThreshold */
	for (s=0; ToDistribute > 0; s = (s+1)%(maxSymbolValue+1))
	if (norm[s] > 0) { ToDistribute--; norm[s]++; }
	return 0;
	}

	{ U64 const vStepLog = 62 - tableLog;
	U64 const mid = (1ULL << (vStepLog-1)) - 1;
	U64 const rStep = ((((U64)1<<vStepLog) * ToDistribute) + mid) / total; /* scale on remaining */
	U64 tmpTotal = mid;
	for (s=0; s<=maxSymbolValue; s++) {
	if (norm[s]==NOT_YET_ASSIGNED) {
	U64 const end = tmpTotal + (count[s] * rStep);
	U32 const sStart = (U32)(tmpTotal >> vStepLog);
	U32 const sEnd = (U32)(end >> vStepLog);
	U32 const weight = sEnd - sStart;
	if (weight < 1)
	return ERROR(GENERIC);
	norm[s] = (short)weight;
	tmpTotal = end;
	} } }

	return 0;
	}


	size_t FSE_normalizeCount (short* normalizedCounter, unsigned tableLog,
	const unsigned* count, size_t total,
	unsigned maxSymbolValue)
	{
	/* Sanity checks */
	if (tableLog==0) tableLog = FSE_DEFAULT_TABLELOG;
	if (tableLog < FSE_MIN_TABLELOG) return ERROR(GENERIC); /* Unsupported size */
	if (tableLog > FSE_MAX_TABLELOG) return ERROR(tableLog_tooLarge); /* Unsupported size */
	if (tableLog < FSE_minTableLog(total, maxSymbolValue)) return ERROR(GENERIC); /* Too small tableLog, compression potentially impossible */

	{ static U32 const rtbTable[] = { 0, 473195, 504333, 520860, 550000, 700000, 750000, 830000 };
	U64 const scale = 62 - tableLog;
	U64 const step = ((U64)1<<62) / total; /* <== here, one division ! */
	U64 const vStep = 1ULL<<(scale-20);
	int stillToDistribute = 1<<tableLog;
	unsigned s;
	unsigned largest=0;
	short largestP=0;
	U32 lowThreshold = (U32)(total >> tableLog);

	for (s=0; s<=maxSymbolValue; s++) {
	if (count[s] == total) return 0; /* rle special case */
	if (count[s] == 0) { normalizedCounter[s]=0; continue; }
	if (count[s] <= lowThreshold) {
	normalizedCounter[s] = -1;
	stillToDistribute--;
	} else {
	short proba = (short)((count[s]*step) >> scale);
	if (proba<8) {
	U64 restToBeat = vStep * rtbTable[proba];
	proba += (count[s]*step) - ((U64)proba<<scale) > restToBeat;
	}
	if (proba > largestP) { largestP=proba; largest=s; }
	normalizedCounter[s] = proba;
	stillToDistribute -= proba;
	} }
	if (-stillToDistribute >= (normalizedCounter[largest] >> 1)) {
	/* corner case, need another normalization method */
	size_t const errorCode = FSE_normalizeM2(normalizedCounter, tableLog, count, total, maxSymbolValue);
	if (FSE_isError(errorCode)) return errorCode;
	}
	else normalizedCounter[largest] += (short)stillToDistribute;
	}

	#if 0
	{ /* Print Table (debug) */
	U32 s;
	U32 nTotal = 0;
	for (s=0; s<=maxSymbolValue; s++)
	RAWLOG(2, "%3i: %4i \n", s, normalizedCounter[s]);
	for (s=0; s<=maxSymbolValue; s++)
	nTotal += abs(normalizedCounter[s]);
	if (nTotal != (1U<<tableLog))
	RAWLOG(2, "Warning !!! Total == %u != %u !!!", nTotal, 1U<<tableLog);
	getchar();
	}
	#endif

	return tableLog;
	}


	/* fake FSE_CTable, for raw (uncompressed) input */
	size_t FSE_buildCTable_raw (FSE_CTable* ct, unsigned nbBits)
	{
	const unsigned tableSize = 1 << nbBits;
	const unsigned tableMask = tableSize - 1;
	const unsigned maxSymbolValue = tableMask;
	void* const ptr = ct;
	U16* const tableU16 = ( (U16*) ptr) + 2;
	void* const FSCT = ((U32)ptr) + 1 / header / + (tableSize>>1); / assumption : tableLog >= 1 */
	FSE_symbolCompressionTransform* const symbolTT = (FSE_symbolCompressionTransform*) (FSCT);
	unsigned s;

	/* Sanity checks */
	if (nbBits < 1) return ERROR(GENERIC); /* min size */

	/* header */
	tableU16[-2] = (U16) nbBits;
	tableU16[-1] = (U16) maxSymbolValue;

	/* Build table */
	for (s=0; s<tableSize; s++)
	tableU16[s] = (U16)(tableSize + s);

	/* Build Symbol Transformation Table */
	{ const U32 deltaNbBits = (nbBits << 16) - (1 << nbBits);
	for (s=0; s<=maxSymbolValue; s++) {
	symbolTT[s].deltaNbBits = deltaNbBits;
	symbolTT[s].deltaFindState = s-1;
	} }

	return 0;
	}

	/* fake FSE_CTable, for rle input (always same symbol) */
	size_t FSE_buildCTable_rle (FSE_CTable* ct, BYTE symbolValue)
	{
	void* ptr = ct;
	U16* tableU16 = ( (U16*) ptr) + 2;
	void* FSCTptr = (U32*)ptr + 2;
	FSE_symbolCompressionTransform* symbolTT = (FSE_symbolCompressionTransform*) FSCTptr;

	/* header */
	tableU16[-2] = (U16) 0;
	tableU16[-1] = (U16) symbolValue;

	/* Build table */
	tableU16[0] = 0;
	tableU16[1] = 0; /* just in case */

	/* Build Symbol Transformation Table */
	symbolTT[symbolValue].deltaNbBits = 0;
	symbolTT[symbolValue].deltaFindState = 0;

	return 0;
	}


	static size_t FSE_compress_usingCTable_generic (void* dst, size_t dstSize,
	const void* src, size_t srcSize,
	const FSE_CTable* ct, const unsigned fast)
	{
	const BYTE* const istart = (const BYTE*) src;
	const BYTE* const iend = istart + srcSize;
	const BYTE* ip=iend;

	BIT_CStream_t bitC;
	FSE_CState_t CState1, CState2;

	/* init */
	if (srcSize <= 2) return 0;
	{ size_t const initError = BIT_initCStream(&bitC, dst, dstSize);
	if (FSE_isError(initError)) return 0; /* not enough space available to write a bitstream */ }

	#define FSE_FLUSHBITS(s) (fast ? BIT_flushBitsFast(s) : BIT_flushBits(s))

	if (srcSize & 1) {
	FSE_initCState2(&CState1, ct, *--ip);
	FSE_initCState2(&CState2, ct, *--ip);
	FSE_encodeSymbol(&bitC, &CState1, *--ip);
	FSE_FLUSHBITS(&bitC);
	} else {
	FSE_initCState2(&CState2, ct, *--ip);
	FSE_initCState2(&CState1, ct, *--ip);
	}

	/* join to mod 4 */
	srcSize -= 2;
	if ((sizeof(bitC.bitContainer)8 > FSE_MAX_TABLELOG4+7 ) && (srcSize & 2)) { /* test bit 2 */
	FSE_encodeSymbol(&bitC, &CState2, *--ip);
	FSE_encodeSymbol(&bitC, &CState1, *--ip);
	FSE_FLUSHBITS(&bitC);
	}

	/* 2 or 4 encoding per loop */
	while ( ip>istart ) {

	FSE_encodeSymbol(&bitC, &CState2, *--ip);

	if (sizeof(bitC.bitContainer)8 < FSE_MAX_TABLELOG2+7 ) /* this test must be static */
	FSE_FLUSHBITS(&bitC);

	FSE_encodeSymbol(&bitC, &CState1, *--ip);

	if (sizeof(bitC.bitContainer)8 > FSE_MAX_TABLELOG4+7 ) { /* this test must be static */
	FSE_encodeSymbol(&bitC, &CState2, *--ip);
	FSE_encodeSymbol(&bitC, &CState1, *--ip);
	}

	FSE_FLUSHBITS(&bitC);
	}

	FSE_flushCState(&bitC, &CState2);
	FSE_flushCState(&bitC, &CState1);
	return BIT_closeCStream(&bitC);
	}

	size_t FSE_compress_usingCTable (void* dst, size_t dstSize,
	const void* src, size_t srcSize,
	const FSE_CTable* ct)
	{
	unsigned const fast = (dstSize >= FSE_BLOCKBOUND(srcSize));

	if (fast)
	return FSE_compress_usingCTable_generic(dst, dstSize, src, srcSize, ct, 1);
	else
	return FSE_compress_usingCTable_generic(dst, dstSize, src, srcSize, ct, 0);
	}


	size_t FSE_compressBound(size_t size) { return FSE_COMPRESSBOUND(size); }

	/* FSE_compress_wksp() :
	* Same as FSE_compress2(), but using an externally allocated scratch buffer (`workSpace`).
	* `wkspSize` size must be `(1<<tableLog)`.
	*/
	size_t FSE_compress_wksp (void* dst, size_t dstSize, const void* src, size_t srcSize, unsigned maxSymbolValue, unsigned tableLog, void* workSpace, size_t wkspSize)
	{
	BYTE* const ostart = (BYTE*) dst;
	BYTE* op = ostart;
	BYTE* const oend = ostart + dstSize;

	unsigned count[FSE_MAX_SYMBOL_VALUE+1];
	S16 norm[FSE_MAX_SYMBOL_VALUE+1];
	FSE_CTable* CTable = (FSE_CTable*)workSpace;
	size_t const CTableSize = FSE_CTABLE_SIZE_U32(tableLog, maxSymbolValue);
	void* scratchBuffer = (void*)(CTable + CTableSize);
	size_t const scratchBufferSize = wkspSize - (CTableSize * sizeof(FSE_CTable));

	/* init conditions */
	if (wkspSize < FSE_WKSP_SIZE_U32(tableLog, maxSymbolValue)) return ERROR(tableLog_tooLarge);
	if (srcSize <= 1) return 0; /* Not compressible */
	if (!maxSymbolValue) maxSymbolValue = FSE_MAX_SYMBOL_VALUE;
	if (!tableLog) tableLog = FSE_DEFAULT_TABLELOG;

	/* Scan input and build symbol stats */
	{ CHECK_V_F(maxCount, HIST_count_wksp(count, &maxSymbolValue, src, srcSize, scratchBuffer, scratchBufferSize) );
	if (maxCount == srcSize) return 1; /* only a single symbol in src : rle */
	if (maxCount == 1) return 0; /* each symbol present maximum once => not compressible */
	if (maxCount < (srcSize >> 7)) return 0; /* Heuristic : not compressible enough */
	}

	tableLog = FSE_optimalTableLog(tableLog, srcSize, maxSymbolValue);
	CHECK_F( FSE_normalizeCount(norm, tableLog, count, srcSize, maxSymbolValue) );

	/* Write table description header */
	{ CHECK_V_F(nc_err, FSE_writeNCount(op, oend-op, norm, maxSymbolValue, tableLog) );
	op += nc_err;
	}

	/* Compress */
	CHECK_F( FSE_buildCTable_wksp(CTable, norm, maxSymbolValue, tableLog, scratchBuffer, scratchBufferSize) );
	{ CHECK_V_F(cSize, FSE_compress_usingCTable(op, oend - op, src, srcSize, CTable) );
	if (cSize == 0) return 0; /* not enough space for compressed data */
	op += cSize;
	}

	/* check compressibility */
	if ( (size_t)(op-ostart) >= srcSize-1 ) return 0;

	return op-ostart;
	}

	typedef struct {
	FSE_CTable CTable_max[FSE_CTABLE_SIZE_U32(FSE_MAX_TABLELOG, FSE_MAX_SYMBOL_VALUE)];
	BYTE scratchBuffer[1 << FSE_MAX_TABLELOG];
	} fseWkspMax_t;

	size_t FSE_compress2 (void* dst, size_t dstCapacity, const void* src, size_t srcSize, unsigned maxSymbolValue, unsigned tableLog)
	{
	fseWkspMax_t scratchBuffer;
	DEBUG_STATIC_ASSERT(sizeof(scratchBuffer) >= FSE_WKSP_SIZE_U32(FSE_MAX_TABLELOG, FSE_MAX_SYMBOL_VALUE)); /* compilation failures here means scratchBuffer is not large enough */
	if (tableLog > FSE_MAX_TABLELOG) return ERROR(tableLog_tooLarge);
	return FSE_compress_wksp(dst, dstCapacity, src, srcSize, maxSymbolValue, tableLog, &scratchBuffer, sizeof(scratchBuffer));
	}

	size_t FSE_compress (void* dst, size_t dstCapacity, const void* src, size_t srcSize)
	{
	return FSE_compress2(dst, dstCapacity, src, srcSize, FSE_MAX_SYMBOL_VALUE, FSE_DEFAULT_TABLELOG);
	}


	#endif /* FSE_COMMONDEFS_ONLY */
	/** ended inlining compress/fse_compress.c **/
	/** start inlining compress/hist.c **/
	/* ******************************************************************
	* hist : Histogram functions
	* part of Finite State Entropy project
	* Copyright (c) 2013-2020, Yann Collet, Facebook, Inc.
	*
	* You can contact the author at :
	* - FSE source repository : https://github.com/Cyan4973/FiniteStateEntropy
	* - Public forum : https://groups.google.com/forum/#!forum/lz4c
	*
	* This source code is licensed under both the BSD-style license (found in the
	* LICENSE file in the root directory of this source tree) and the GPLv2 (found
	* in the COPYING file in the root directory of this source tree).
	* You may select, at your option, one of the above-listed licenses.
	****************************************************************** */

	/* --- dependencies --- */
	/** skipping file: ../common/mem.h **/
	/** skipping file: ../common/debug.h **/
	/** skipping file: ../common/error_private.h **/
	/** skipping file: hist.h **/


	/* --- Error management --- */
	unsigned HIST_isError(size_t code) { return ERR_isError(code); }

	/-*************************************************************
	* Histogram functions
	****************************************************************/
	unsigned HIST_count_simple(unsigned* count, unsigned* maxSymbolValuePtr,
	const void* src, size_t srcSize)
	{
	const BYTE* ip = (const BYTE*)src;
	const BYTE* const end = ip + srcSize;
	unsigned maxSymbolValue = *maxSymbolValuePtr;
	unsigned largestCount=0;

	memset(count, 0, (maxSymbolValue+1) * sizeof(*count));
	if (srcSize==0) { *maxSymbolValuePtr = 0; return 0; }

	while (ip<end) {
	assert(*ip <= maxSymbolValue);
	count[*ip++]++;
	}

	while (!count[maxSymbolValue]) maxSymbolValue--;
	*maxSymbolValuePtr = maxSymbolValue;

	{ U32 s;
	for (s=0; s<=maxSymbolValue; s++)
	if (count[s] > largestCount) largestCount = count[s];
	}

	return largestCount;
	}

	typedef enum { trustInput, checkMaxSymbolValue } HIST_checkInput_e;

	/* HIST_count_parallel_wksp() :
	* store histogram into 4 intermediate tables, recombined at the end.
	* this design makes better use of OoO cpus,
	* and is noticeably faster when some values are heavily repeated.
	* But it needs some additional workspace for intermediate tables.
	* `workSpace` size must be a table of size >= HIST_WKSP_SIZE_U32.
	* @return : largest histogram frequency,
	* or an error code (notably when histogram would be larger than maxSymbolValuePtr). /
	static size_t HIST_count_parallel_wksp(
	unsigned* count, unsigned* maxSymbolValuePtr,
	const void* source, size_t sourceSize,
	HIST_checkInput_e check,
	U32* const workSpace)
	{
	const BYTE* ip = (const BYTE*)source;
	const BYTE* const iend = ip+sourceSize;
	unsigned maxSymbolValue = *maxSymbolValuePtr;
	unsigned max=0;
	U32* const Counting1 = workSpace;
	U32* const Counting2 = Counting1 + 256;
	U32* const Counting3 = Counting2 + 256;
	U32* const Counting4 = Counting3 + 256;

	memset(workSpace, 0, 4256sizeof(unsigned));

	/* safety checks */
	if (!sourceSize) {
	memset(count, 0, maxSymbolValue + 1);
	*maxSymbolValuePtr = 0;
	return 0;
	}
	if (!maxSymbolValue) maxSymbolValue = 255; /* 0 == default */

	/* by stripes of 16 bytes */
	{ U32 cached = MEM_read32(ip); ip += 4;
	while (ip < iend-15) {
	U32 c = cached; cached = MEM_read32(ip); ip += 4;
	Counting1[(BYTE) c ]++;
	Counting2[(BYTE)(c>>8) ]++;
	Counting3[(BYTE)(c>>16)]++;
	Counting4[ c>>24 ]++;
	c = cached; cached = MEM_read32(ip); ip += 4;
	Counting1[(BYTE) c ]++;
	Counting2[(BYTE)(c>>8) ]++;
	Counting3[(BYTE)(c>>16)]++;
	Counting4[ c>>24 ]++;
	c = cached; cached = MEM_read32(ip); ip += 4;
	Counting1[(BYTE) c ]++;
	Counting2[(BYTE)(c>>8) ]++;
	Counting3[(BYTE)(c>>16)]++;
	Counting4[ c>>24 ]++;
	c = cached; cached = MEM_read32(ip); ip += 4;
	Counting1[(BYTE) c ]++;
	Counting2[(BYTE)(c>>8) ]++;
	Counting3[(BYTE)(c>>16)]++;
	Counting4[ c>>24 ]++;
	}
	ip-=4;
	}

	/* finish last symbols */
	while (ip<iend) Counting1[*ip++]++;

	if (check) { /* verify stats will fit into destination table */
	U32 s; for (s=255; s>maxSymbolValue; s--) {
	Counting1[s] += Counting2[s] + Counting3[s] + Counting4[s];
	if (Counting1[s]) return ERROR(maxSymbolValue_tooSmall);
	} }

	{ U32 s;
	if (maxSymbolValue > 255) maxSymbolValue = 255;
	for (s=0; s<=maxSymbolValue; s++) {
	count[s] = Counting1[s] + Counting2[s] + Counting3[s] + Counting4[s];
	if (count[s] > max) max = count[s];
	} }

	while (!count[maxSymbolValue]) maxSymbolValue--;
	*maxSymbolValuePtr = maxSymbolValue;
	return (size_t)max;
	}

	/* HIST_countFast_wksp() :
	* Same as HIST_countFast(), but using an externally provided scratch buffer.
	* `workSpace` is a writable buffer which must be 4-bytes aligned,
	* `workSpaceSize` must be >= HIST_WKSP_SIZE
	*/
	size_t HIST_countFast_wksp(unsigned* count, unsigned* maxSymbolValuePtr,
	const void* source, size_t sourceSize,
	void* workSpace, size_t workSpaceSize)
	{
	if (sourceSize < 1500) /* heuristic threshold */
	return HIST_count_simple(count, maxSymbolValuePtr, source, sourceSize);
	if ((size_t)workSpace & 3) return ERROR(GENERIC); /* must be aligned on 4-bytes boundaries */
	if (workSpaceSize < HIST_WKSP_SIZE) return ERROR(workSpace_tooSmall);
	return HIST_count_parallel_wksp(count, maxSymbolValuePtr, source, sourceSize, trustInput, (U32*)workSpace);
	}

	/* fast variant (unsafe : won't check if src contains values beyond count[] limit) */
	size_t HIST_countFast(unsigned* count, unsigned* maxSymbolValuePtr,
	const void* source, size_t sourceSize)
	{
	unsigned tmpCounters[HIST_WKSP_SIZE_U32];
	return HIST_countFast_wksp(count, maxSymbolValuePtr, source, sourceSize, tmpCounters, sizeof(tmpCounters));
	}

	/* HIST_count_wksp() :
	* Same as HIST_count(), but using an externally provided scratch buffer.
	* `workSpace` size must be table of >= HIST_WKSP_SIZE_U32 unsigned */
	size_t HIST_count_wksp(unsigned* count, unsigned* maxSymbolValuePtr,
	const void* source, size_t sourceSize,
	void* workSpace, size_t workSpaceSize)
	{
	if ((size_t)workSpace & 3) return ERROR(GENERIC); /* must be aligned on 4-bytes boundaries */
	if (workSpaceSize < HIST_WKSP_SIZE) return ERROR(workSpace_tooSmall);
	if (*maxSymbolValuePtr < 255)
	return HIST_count_parallel_wksp(count, maxSymbolValuePtr, source, sourceSize, checkMaxSymbolValue, (U32*)workSpace);
	*maxSymbolValuePtr = 255;
	return HIST_countFast_wksp(count, maxSymbolValuePtr, source, sourceSize, workSpace, workSpaceSize);
	}

	size_t HIST_count(unsigned* count, unsigned* maxSymbolValuePtr,
	const void* src, size_t srcSize)
	{
	unsigned tmpCounters[HIST_WKSP_SIZE_U32];
	return HIST_count_wksp(count, maxSymbolValuePtr, src, srcSize, tmpCounters, sizeof(tmpCounters));
	}
	/** ended inlining compress/hist.c **/
	/** start inlining compress/huf_compress.c **/
	/* ******************************************************************
	* Huffman encoder, part of New Generation Entropy library
	* Copyright (c) 2013-2020, Yann Collet, Facebook, Inc.
	*
	* You can contact the author at :
	* - FSE+HUF source repository : https://github.com/Cyan4973/FiniteStateEntropy
	* - Public forum : https://groups.google.com/forum/#!forum/lz4c
	*
	* This source code is licensed under both the BSD-style license (found in the
	* LICENSE file in the root directory of this source tree) and the GPLv2 (found
	* in the COPYING file in the root directory of this source tree).
	* You may select, at your option, one of the above-listed licenses.
	****************************************************************** */

	/* **************************************************************
	* Compiler specifics
	****************************************************************/
	#ifdef _MSC_VER /* Visual Studio */
	# pragma warning(disable : 4127) /* disable: C4127: conditional expression is constant */
	#endif


	/* **************************************************************
	* Includes
	****************************************************************/
	#include <string.h> /* memcpy, memset */
	#include <stdio.h> /* printf (debug) */
	/** skipping file: ../common/compiler.h **/
	/** skipping file: ../common/bitstream.h **/
	/** skipping file: hist.h **/
	#define FSE_STATIC_LINKING_ONLY /* FSE_optimalTableLog_internal */
	/** skipping file: ../common/fse.h **/
	#define HUF_STATIC_LINKING_ONLY
	/** skipping file: ../common/huf.h **/
	/** skipping file: ../common/error_private.h **/


	/* **************************************************************
	* Error Management
	****************************************************************/
	#define HUF_isError ERR_isError
	#define HUF_STATIC_ASSERT(c) DEBUG_STATIC_ASSERT(c) /* use only after variable declarations */


	/* **************************************************************
	* Utils
	****************************************************************/
	unsigned HUF_optimalTableLog(unsigned maxTableLog, size_t srcSize, unsigned maxSymbolValue)
	{
	return FSE_optimalTableLog_internal(maxTableLog, srcSize, maxSymbolValue, 1);
	}


	/* *******************************************************
	* HUF : Huffman block compression
	*********************************************************/
	/* HUF_compressWeights() :
	* Same as FSE_compress(), but dedicated to huff0's weights compression.
	* The use case needs much less stack memory.
	* Note : all elements within weightTable are supposed to be <= HUF_TABLELOG_MAX.
	*/
	#define MAX_FSE_TABLELOG_FOR_HUFF_HEADER 6
	static size_t HUF_compressWeights (void* dst, size_t dstSize, const void* weightTable, size_t wtSize)
	{
	BYTE* const ostart = (BYTE*) dst;
	BYTE* op = ostart;
	BYTE* const oend = ostart + dstSize;

	unsigned maxSymbolValue = HUF_TABLELOG_MAX;
	U32 tableLog = MAX_FSE_TABLELOG_FOR_HUFF_HEADER;

	FSE_CTable CTable[FSE_CTABLE_SIZE_U32(MAX_FSE_TABLELOG_FOR_HUFF_HEADER, HUF_TABLELOG_MAX)];
	BYTE scratchBuffer[1<<MAX_FSE_TABLELOG_FOR_HUFF_HEADER];

	unsigned count[HUF_TABLELOG_MAX+1];
	S16 norm[HUF_TABLELOG_MAX+1];

	/* init conditions */
	if (wtSize <= 1) return 0; /* Not compressible */

	/* Scan input and build symbol stats */
	{ unsigned const maxCount = HIST_count_simple(count, &maxSymbolValue, weightTable, wtSize); /* never fails */
	if (maxCount == wtSize) return 1; /* only a single symbol in src : rle */
	if (maxCount == 1) return 0; /* each symbol present maximum once => not compressible */
	}

	tableLog = FSE_optimalTableLog(tableLog, wtSize, maxSymbolValue);
	CHECK_F( FSE_normalizeCount(norm, tableLog, count, wtSize, maxSymbolValue) );

	/* Write table description header */
	{ CHECK_V_F(hSize, FSE_writeNCount(op, (size_t)(oend-op), norm, maxSymbolValue, tableLog) );
	op += hSize;
	}

	/* Compress */
	CHECK_F( FSE_buildCTable_wksp(CTable, norm, maxSymbolValue, tableLog, scratchBuffer, sizeof(scratchBuffer)) );
	{ CHECK_V_F(cSize, FSE_compress_usingCTable(op, (size_t)(oend - op), weightTable, wtSize, CTable) );
	if (cSize == 0) return 0; /* not enough space for compressed data */
	op += cSize;
	}

	return (size_t)(op-ostart);
	}


	struct HUF_CElt_s {
	U16 val;
	BYTE nbBits;
	}; /* typedef'd to HUF_CElt within "huf.h" */

	/*! HUF_writeCTable() :
	`CTable` : Huffman tree to save, using huf representation.
	@return : size of saved CTable */
	size_t HUF_writeCTable (void* dst, size_t maxDstSize,
	const HUF_CElt* CTable, unsigned maxSymbolValue, unsigned huffLog)
	{
	BYTE bitsToWeight[HUF_TABLELOG_MAX + 1]; /* precomputed conversion table */
	BYTE huffWeight[HUF_SYMBOLVALUE_MAX];
	BYTE* op = (BYTE*)dst;
	U32 n;

	/* check conditions */
	if (maxSymbolValue > HUF_SYMBOLVALUE_MAX) return ERROR(maxSymbolValue_tooLarge);

	/* convert to weight */
	bitsToWeight[0] = 0;
	for (n=1; n<huffLog+1; n++)
	bitsToWeight[n] = (BYTE)(huffLog + 1 - n);
	for (n=0; n<maxSymbolValue; n++)
	huffWeight[n] = bitsToWeight[CTable[n].nbBits];

	/* attempt weights compression by FSE */
	{ CHECK_V_F(hSize, HUF_compressWeights(op+1, maxDstSize-1, huffWeight, maxSymbolValue) );
	if ((hSize>1) & (hSize < maxSymbolValue/2)) { /* FSE compressed */
	op[0] = (BYTE)hSize;
	return hSize+1;
	} }

	/* write raw values as 4-bits (max : 15) */
	if (maxSymbolValue > (256-128)) return ERROR(GENERIC); /* should not happen : likely means source cannot be compressed */
	if (((maxSymbolValue+1)/2) + 1 > maxDstSize) return ERROR(dstSize_tooSmall); /* not enough space within dst buffer */
	op[0] = (BYTE)(128 /special case/ + (maxSymbolValue-1));
	huffWeight[maxSymbolValue] = 0; /* to be sure it doesn't cause msan issue in final combination */
	for (n=0; n<maxSymbolValue; n+=2)
	op[(n/2)+1] = (BYTE)((huffWeight[n] << 4) + huffWeight[n+1]);
	return ((maxSymbolValue+1)/2) + 1;
	}


	size_t HUF_readCTable (HUF_CElt* CTable, unsigned* maxSymbolValuePtr, const void* src, size_t srcSize, unsigned* hasZeroWeights)
	{
	BYTE huffWeight[HUF_SYMBOLVALUE_MAX + 1]; /* init not required, even though some static analyzer may complain */
	U32 rankVal[HUF_TABLELOG_ABSOLUTEMAX + 1]; /* large enough for values from 0 to 16 */
	U32 tableLog = 0;
	U32 nbSymbols = 0;

	/* get symbol weights */
	CHECK_V_F(readSize, HUF_readStats(huffWeight, HUF_SYMBOLVALUE_MAX+1, rankVal, &nbSymbols, &tableLog, src, srcSize));

	/* check result */
	if (tableLog > HUF_TABLELOG_MAX) return ERROR(tableLog_tooLarge);
	if (nbSymbols > *maxSymbolValuePtr+1) return ERROR(maxSymbolValue_tooSmall);

	/* Prepare base value per rank */
	{ U32 n, nextRankStart = 0;
	for (n=1; n<=tableLog; n++) {
	U32 current = nextRankStart;
	nextRankStart += (rankVal[n] << (n-1));
	rankVal[n] = current;
	} }

	/* fill nbBits */
	*hasZeroWeights = 0;
	{ U32 n; for (n=0; n<nbSymbols; n++) {
	const U32 w = huffWeight[n];
	*hasZeroWeights \|= (w == 0);
	CTable[n].nbBits = (BYTE)(tableLog + 1 - w) & -(w != 0);
	} }

	/* fill val */
	{ U16 nbPerRank[HUF_TABLELOG_MAX+2] = {0}; /* support w=0=>n=tableLog+1 */
	U16 valPerRank[HUF_TABLELOG_MAX+2] = {0};
	{ U32 n; for (n=0; n<nbSymbols; n++) nbPerRank[CTable[n].nbBits]++; }
	/* determine stating value per rank */
	valPerRank[tableLog+1] = 0; /* for w==0 */
	{ U16 min = 0;
	U32 n; for (n=tableLog; n>0; n--) { /* start at n=tablelog <-> w=1 */
	valPerRank[n] = min; /* get starting value within each rank */
	min += nbPerRank[n];
	min >>= 1;
	} }
	/* assign value within rank, symbol order */
	{ U32 n; for (n=0; n<nbSymbols; n++) CTable[n].val = valPerRank[CTable[n].nbBits]++; }
	}

	*maxSymbolValuePtr = nbSymbols - 1;
	return readSize;
	}

	U32 HUF_getNbBits(const void* symbolTable, U32 symbolValue)
	{
	const HUF_CElt* table = (const HUF_CElt*)symbolTable;
	assert(symbolValue <= HUF_SYMBOLVALUE_MAX);
	return table[symbolValue].nbBits;
	}


	typedef struct nodeElt_s {
	U32 count;
	U16 parent;
	BYTE byte;
	BYTE nbBits;
	} nodeElt;

	static U32 HUF_setMaxHeight(nodeElt* huffNode, U32 lastNonNull, U32 maxNbBits)
	{
	const U32 largestBits = huffNode[lastNonNull].nbBits;
	if (largestBits <= maxNbBits) return largestBits; /* early exit : no elt > maxNbBits */

	/* there are several too large elements (at least >= 2) */
	{ int totalCost = 0;
	const U32 baseCost = 1 << (largestBits - maxNbBits);
	int n = (int)lastNonNull;

	while (huffNode[n].nbBits > maxNbBits) {
	totalCost += baseCost - (1 << (largestBits - huffNode[n].nbBits));
	huffNode[n].nbBits = (BYTE)maxNbBits;
	n --;
	} /* n stops at huffNode[n].nbBits <= maxNbBits */
	while (huffNode[n].nbBits == maxNbBits) n--; /* n end at index of smallest symbol using < maxNbBits */

	/* renorm totalCost */
	totalCost >>= (largestBits - maxNbBits); /* note : totalCost is necessarily a multiple of baseCost */

	/* repay normalized cost */
	{ U32 const noSymbol = 0xF0F0F0F0;
	U32 rankLast[HUF_TABLELOG_MAX+2];

	/* Get pos of last (smallest) symbol per rank */
	memset(rankLast, 0xF0, sizeof(rankLast));
	{ U32 currentNbBits = maxNbBits;
	int pos;
	for (pos=n ; pos >= 0; pos--) {
	if (huffNode[pos].nbBits >= currentNbBits) continue;
	currentNbBits = huffNode[pos].nbBits; /* < maxNbBits */
	rankLast[maxNbBits-currentNbBits] = (U32)pos;
	} }

	while (totalCost > 0) {
	U32 nBitsToDecrease = BIT_highbit32((U32)totalCost) + 1;
	for ( ; nBitsToDecrease > 1; nBitsToDecrease--) {
	U32 const highPos = rankLast[nBitsToDecrease];
	U32 const lowPos = rankLast[nBitsToDecrease-1];
	if (highPos == noSymbol) continue;
	if (lowPos == noSymbol) break;
	{ U32 const highTotal = huffNode[highPos].count;
	U32 const lowTotal = 2 * huffNode[lowPos].count;
	if (highTotal <= lowTotal) break;
	} }
	/* only triggered when no more rank 1 symbol left => find closest one (note : there is necessarily at least one !) */
	/* HUF_MAX_TABLELOG test just to please gcc 5+; but it should not be necessary */
	while ((nBitsToDecrease<=HUF_TABLELOG_MAX) && (rankLast[nBitsToDecrease] == noSymbol))
	nBitsToDecrease ++;
	totalCost -= 1 << (nBitsToDecrease-1);
	if (rankLast[nBitsToDecrease-1] == noSymbol)
	rankLast[nBitsToDecrease-1] = rankLast[nBitsToDecrease]; /* this rank is no longer empty */
	huffNode[rankLast[nBitsToDecrease]].nbBits ++;
	if (rankLast[nBitsToDecrease] == 0) /* special case, reached largest symbol */
	rankLast[nBitsToDecrease] = noSymbol;
	else {
	rankLast[nBitsToDecrease]--;
	if (huffNode[rankLast[nBitsToDecrease]].nbBits != maxNbBits-nBitsToDecrease)
	rankLast[nBitsToDecrease] = noSymbol; /* this rank is now empty */
	} } /* while (totalCost > 0) */

	while (totalCost < 0) { /* Sometimes, cost correction overshoot */
	if (rankLast[1] == noSymbol) { /* special case : no rank 1 symbol (using maxNbBits-1); let's create one from largest rank 0 (using maxNbBits) */
	while (huffNode[n].nbBits == maxNbBits) n--;
	huffNode[n+1].nbBits--;
	assert(n >= 0);
	rankLast[1] = (U32)(n+1);
	totalCost++;
	continue;
	}
	huffNode[ rankLast[1] + 1 ].nbBits--;
	rankLast[1]++;
	totalCost ++;
	} } } /* there are several too large elements (at least >= 2) */

	return maxNbBits;
	}

	typedef struct {
	U32 base;
	U32 current;
	} rankPos;

	typedef nodeElt huffNodeTable[HUF_CTABLE_WORKSPACE_SIZE_U32];

	#define RANK_POSITION_TABLE_SIZE 32

	typedef struct {
	huffNodeTable huffNodeTbl;
	rankPos rankPosition[RANK_POSITION_TABLE_SIZE];
	} HUF_buildCTable_wksp_tables;

	static void HUF_sort(nodeElt* huffNode, const unsigned* count, U32 maxSymbolValue, rankPos* rankPosition)
	{
	U32 n;

	memset(rankPosition, 0, sizeof(rankPosition) RANK_POSITION_TABLE_SIZE);
	for (n=0; n<=maxSymbolValue; n++) {
	U32 r = BIT_highbit32(count[n] + 1);
	rankPosition[r].base ++;
	}
	for (n=30; n>0; n--) rankPosition[n-1].base += rankPosition[n].base;
	for (n=0; n<32; n++) rankPosition[n].current = rankPosition[n].base;
	for (n=0; n<=maxSymbolValue; n++) {
	U32 const c = count[n];
	U32 const r = BIT_highbit32(c+1) + 1;
	U32 pos = rankPosition[r].current++;
	while ((pos > rankPosition[r].base) && (c > huffNode[pos-1].count)) {
	huffNode[pos] = huffNode[pos-1];
	pos--;
	}
	huffNode[pos].count = c;
	huffNode[pos].byte = (BYTE)n;
	}
	}


	/** HUF_buildCTable_wksp() :
	* Same as HUF_buildCTable(), but using externally allocated scratch buffer.
	* `workSpace` must be aligned on 4-bytes boundaries, and be at least as large as sizeof(HUF_buildCTable_wksp_tables).
	*/
	#define STARTNODE (HUF_SYMBOLVALUE_MAX+1)

	size_t HUF_buildCTable_wksp (HUF_CElt* tree, const unsigned* count, U32 maxSymbolValue, U32 maxNbBits, void* workSpace, size_t wkspSize)
	{
	HUF_buildCTable_wksp_tables* const wksp_tables = (HUF_buildCTable_wksp_tables*)workSpace;
	nodeElt* const huffNode0 = wksp_tables->huffNodeTbl;
	nodeElt* const huffNode = huffNode0+1;
	int nonNullRank;
	int lowS, lowN;
	int nodeNb = STARTNODE;
	int n, nodeRoot;

	/* safety checks */
	if (((size_t)workSpace & 3) != 0) return ERROR(GENERIC); /* must be aligned on 4-bytes boundaries */
	if (wkspSize < sizeof(HUF_buildCTable_wksp_tables))
	return ERROR(workSpace_tooSmall);
	if (maxNbBits == 0) maxNbBits = HUF_TABLELOG_DEFAULT;
	if (maxSymbolValue > HUF_SYMBOLVALUE_MAX)
	return ERROR(maxSymbolValue_tooLarge);
	memset(huffNode0, 0, sizeof(huffNodeTable));

	/* sort, decreasing order */
	HUF_sort(huffNode, count, maxSymbolValue, wksp_tables->rankPosition);

	/* init for parents */
	nonNullRank = (int)maxSymbolValue;
	while(huffNode[nonNullRank].count == 0) nonNullRank--;
	lowS = nonNullRank; nodeRoot = nodeNb + lowS - 1; lowN = nodeNb;
	huffNode[nodeNb].count = huffNode[lowS].count + huffNode[lowS-1].count;
	huffNode[lowS].parent = huffNode[lowS-1].parent = (U16)nodeNb;
	nodeNb++; lowS-=2;
	for (n=nodeNb; n<=nodeRoot; n++) huffNode[n].count = (U32)(1U<<30);
	huffNode0[0].count = (U32)(1U<<31); /* fake entry, strong barrier */

	/* create parents */
	while (nodeNb <= nodeRoot) {
	int const n1 = (huffNode[lowS].count < huffNode[lowN].count) ? lowS-- : lowN++;
	int const n2 = (huffNode[lowS].count < huffNode[lowN].count) ? lowS-- : lowN++;
	huffNode[nodeNb].count = huffNode[n1].count + huffNode[n2].count;
	huffNode[n1].parent = huffNode[n2].parent = (U16)nodeNb;
	nodeNb++;
	}

	/* distribute weights (unlimited tree height) */
	huffNode[nodeRoot].nbBits = 0;
	for (n=nodeRoot-1; n>=STARTNODE; n--)
	huffNode[n].nbBits = huffNode[ huffNode[n].parent ].nbBits + 1;
	for (n=0; n<=nonNullRank; n++)
	huffNode[n].nbBits = huffNode[ huffNode[n].parent ].nbBits + 1;

	/* enforce maxTableLog */
	maxNbBits = HUF_setMaxHeight(huffNode, (U32)nonNullRank, maxNbBits);

	/* fill result into tree (val, nbBits) */
	{ U16 nbPerRank[HUF_TABLELOG_MAX+1] = {0};
	U16 valPerRank[HUF_TABLELOG_MAX+1] = {0};
	int const alphabetSize = (int)(maxSymbolValue + 1);
	if (maxNbBits > HUF_TABLELOG_MAX) return ERROR(GENERIC); /* check fit into table */
	for (n=0; n<=nonNullRank; n++)
	nbPerRank[huffNode[n].nbBits]++;
	/* determine stating value per rank */
	{ U16 min = 0;
	for (n=(int)maxNbBits; n>0; n--) {
	valPerRank[n] = min; /* get starting value within each rank */
	min += nbPerRank[n];
	min >>= 1;
	} }
	for (n=0; n<alphabetSize; n++)
	tree[huffNode[n].byte].nbBits = huffNode[n].nbBits; /* push nbBits per symbol, symbol order */
	for (n=0; n<alphabetSize; n++)
	tree[n].val = valPerRank[tree[n].nbBits]++; /* assign value within rank, symbol order */
	}

	return maxNbBits;
	}

	/** HUF_buildCTable() :
	* @return : maxNbBits
	* Note : count is used before tree is written, so they can safely overlap
	*/
	size_t HUF_buildCTable (HUF_CElt* tree, const unsigned* count, unsigned maxSymbolValue, unsigned maxNbBits)
	{
	HUF_buildCTable_wksp_tables workspace;
	return HUF_buildCTable_wksp(tree, count, maxSymbolValue, maxNbBits, &workspace, sizeof(workspace));
	}

	size_t HUF_estimateCompressedSize(const HUF_CElt* CTable, const unsigned* count, unsigned maxSymbolValue)
	{
	size_t nbBits = 0;
	int s;
	for (s = 0; s <= (int)maxSymbolValue; ++s) {
	nbBits += CTable[s].nbBits * count[s];
	}
	return nbBits >> 3;
	}

	int HUF_validateCTable(const HUF_CElt* CTable, const unsigned* count, unsigned maxSymbolValue) {
	int bad = 0;
	int s;
	for (s = 0; s <= (int)maxSymbolValue; ++s) {
	bad \|= (count[s] != 0) & (CTable[s].nbBits == 0);
	}
	return !bad;
	}

	size_t HUF_compressBound(size_t size) { return HUF_COMPRESSBOUND(size); }

	FORCE_INLINE_TEMPLATE void
	HUF_encodeSymbol(BIT_CStream_t* bitCPtr, U32 symbol, const HUF_CElt* CTable)
	{
	BIT_addBitsFast(bitCPtr, CTable[symbol].val, CTable[symbol].nbBits);
	}

	#define HUF_FLUSHBITS(s) BIT_flushBits(s)

	#define HUF_FLUSHBITS_1(stream) \
	if (sizeof((stream)->bitContainer)8 < HUF_TABLELOG_MAX2+7) HUF_FLUSHBITS(stream)

	#define HUF_FLUSHBITS_2(stream) \
	if (sizeof((stream)->bitContainer)8 < HUF_TABLELOG_MAX4+7) HUF_FLUSHBITS(stream)

	FORCE_INLINE_TEMPLATE size_t
	HUF_compress1X_usingCTable_internal_body(void* dst, size_t dstSize,
	const void* src, size_t srcSize,
	const HUF_CElt* CTable)
	{
	const BYTE* ip = (const BYTE*) src;
	BYTE* const ostart = (BYTE*)dst;
	BYTE* const oend = ostart + dstSize;
	BYTE* op = ostart;
	size_t n;
	BIT_CStream_t bitC;

	/* init */
	if (dstSize < 8) return 0; /* not enough space to compress */
	{ size_t const initErr = BIT_initCStream(&bitC, op, (size_t)(oend-op));
	if (HUF_isError(initErr)) return 0; }

	n = srcSize & ~3; /* join to mod 4 */
	switch (srcSize & 3)
	{
	case 3 : HUF_encodeSymbol(&bitC, ip[n+ 2], CTable);
	HUF_FLUSHBITS_2(&bitC);
	/* fall-through */
	case 2 : HUF_encodeSymbol(&bitC, ip[n+ 1], CTable);
	HUF_FLUSHBITS_1(&bitC);
	/* fall-through */
	case 1 : HUF_encodeSymbol(&bitC, ip[n+ 0], CTable);
	HUF_FLUSHBITS(&bitC);
	/* fall-through */
	case 0 : /* fall-through */
	default: break;
	}

	for (; n>0; n-=4) { /* note : n&3==0 at this stage */
	HUF_encodeSymbol(&bitC, ip[n- 1], CTable);
	HUF_FLUSHBITS_1(&bitC);
	HUF_encodeSymbol(&bitC, ip[n- 2], CTable);
	HUF_FLUSHBITS_2(&bitC);
	HUF_encodeSymbol(&bitC, ip[n- 3], CTable);
	HUF_FLUSHBITS_1(&bitC);
	HUF_encodeSymbol(&bitC, ip[n- 4], CTable);
	HUF_FLUSHBITS(&bitC);
	}

	return BIT_closeCStream(&bitC);
	}

	#if DYNAMIC_BMI2

	static TARGET_ATTRIBUTE("bmi2") size_t
	HUF_compress1X_usingCTable_internal_bmi2(void* dst, size_t dstSize,
	const void* src, size_t srcSize,
	const HUF_CElt* CTable)
	{
	return HUF_compress1X_usingCTable_internal_body(dst, dstSize, src, srcSize, CTable);
	}

	static size_t
	HUF_compress1X_usingCTable_internal_default(void* dst, size_t dstSize,
	const void* src, size_t srcSize,
	const HUF_CElt* CTable)
	{
	return HUF_compress1X_usingCTable_internal_body(dst, dstSize, src, srcSize, CTable);
	}

	static size_t
	HUF_compress1X_usingCTable_internal(void* dst, size_t dstSize,
	const void* src, size_t srcSize,
	const HUF_CElt* CTable, const int bmi2)
	{
	if (bmi2) {
	return HUF_compress1X_usingCTable_internal_bmi2(dst, dstSize, src, srcSize, CTable);
	}
	return HUF_compress1X_usingCTable_internal_default(dst, dstSize, src, srcSize, CTable);
	}

	#else

	static size_t
	HUF_compress1X_usingCTable_internal(void* dst, size_t dstSize,
	const void* src, size_t srcSize,
	const HUF_CElt* CTable, const int bmi2)
	{
	(void)bmi2;
	return HUF_compress1X_usingCTable_internal_body(dst, dstSize, src, srcSize, CTable);
	}

	#endif

	size_t HUF_compress1X_usingCTable(void* dst, size_t dstSize, const void* src, size_t srcSize, const HUF_CElt* CTable)
	{
	return HUF_compress1X_usingCTable_internal(dst, dstSize, src, srcSize, CTable, /* bmi2 */ 0);
	}


	static size_t
	HUF_compress4X_usingCTable_internal(void* dst, size_t dstSize,
	const void* src, size_t srcSize,
	const HUF_CElt* CTable, int bmi2)
	{
	size_t const segmentSize = (srcSize+3)/4; /* first 3 segments */
	const BYTE* ip = (const BYTE*) src;
	const BYTE* const iend = ip + srcSize;
	BYTE* const ostart = (BYTE*) dst;
	BYTE* const oend = ostart + dstSize;
	BYTE* op = ostart;

	if (dstSize < 6 + 1 + 1 + 1 + 8) return 0; /* minimum space to compress successfully */
	if (srcSize < 12) return 0; /* no saving possible : too small input */
	op += 6; /* jumpTable */

	assert(op <= oend);
	{ CHECK_V_F(cSize, HUF_compress1X_usingCTable_internal(op, (size_t)(oend-op), ip, segmentSize, CTable, bmi2) );
	if (cSize==0) return 0;
	assert(cSize <= 65535);
	MEM_writeLE16(ostart, (U16)cSize);
	op += cSize;
	}

	ip += segmentSize;
	assert(op <= oend);
	{ CHECK_V_F(cSize, HUF_compress1X_usingCTable_internal(op, (size_t)(oend-op), ip, segmentSize, CTable, bmi2) );
	if (cSize==0) return 0;
	assert(cSize <= 65535);
	MEM_writeLE16(ostart+2, (U16)cSize);
	op += cSize;
	}

	ip += segmentSize;
	assert(op <= oend);
	{ CHECK_V_F(cSize, HUF_compress1X_usingCTable_internal(op, (size_t)(oend-op), ip, segmentSize, CTable, bmi2) );
	if (cSize==0) return 0;
	assert(cSize <= 65535);
	MEM_writeLE16(ostart+4, (U16)cSize);
	op += cSize;
	}

	ip += segmentSize;
	assert(op <= oend);
	assert(ip <= iend);
	{ CHECK_V_F(cSize, HUF_compress1X_usingCTable_internal(op, (size_t)(oend-op), ip, (size_t)(iend-ip), CTable, bmi2) );
	if (cSize==0) return 0;
	op += cSize;
	}

	return (size_t)(op-ostart);
	}

	size_t HUF_compress4X_usingCTable(void* dst, size_t dstSize, const void* src, size_t srcSize, const HUF_CElt* CTable)
	{
	return HUF_compress4X_usingCTable_internal(dst, dstSize, src, srcSize, CTable, /* bmi2 */ 0);
	}

	typedef enum { HUF_singleStream, HUF_fourStreams } HUF_nbStreams_e;

	static size_t HUF_compressCTable_internal(
	BYTE* const ostart, BYTE* op, BYTE* const oend,
	const void* src, size_t srcSize,
	HUF_nbStreams_e nbStreams, const HUF_CElt* CTable, const int bmi2)
	{
	size_t const cSize = (nbStreams==HUF_singleStream) ?
	HUF_compress1X_usingCTable_internal(op, (size_t)(oend - op), src, srcSize, CTable, bmi2) :
	HUF_compress4X_usingCTable_internal(op, (size_t)(oend - op), src, srcSize, CTable, bmi2);
	if (HUF_isError(cSize)) { return cSize; }
	if (cSize==0) { return 0; } /* uncompressible */
	op += cSize;
	/* check compressibility */
	assert(op >= ostart);
	if ((size_t)(op-ostart) >= srcSize-1) { return 0; }
	return (size_t)(op-ostart);
	}

	typedef struct {
	unsigned count[HUF_SYMBOLVALUE_MAX + 1];
	HUF_CElt CTable[HUF_SYMBOLVALUE_MAX + 1];
	HUF_buildCTable_wksp_tables buildCTable_wksp;
	} HUF_compress_tables_t;

	/* HUF_compress_internal() :
	* `workSpace` must a table of at least HUF_WORKSPACE_SIZE_U32 unsigned */
	static size_t
	HUF_compress_internal (void* dst, size_t dstSize,
	const void* src, size_t srcSize,
	unsigned maxSymbolValue, unsigned huffLog,
	HUF_nbStreams_e nbStreams,
	void* workSpace, size_t wkspSize,
	HUF_CElt* oldHufTable, HUF_repeat* repeat, int preferRepeat,
	const int bmi2)
	{
	HUF_compress_tables_t* const table = (HUF_compress_tables_t*)workSpace;
	BYTE* const ostart = (BYTE*)dst;
	BYTE* const oend = ostart + dstSize;
	BYTE* op = ostart;

	HUF_STATIC_ASSERT(sizeof(*table) <= HUF_WORKSPACE_SIZE);

	/* checks & inits */
	if (((size_t)workSpace & 3) != 0) return ERROR(GENERIC); /* must be aligned on 4-bytes boundaries */
	if (wkspSize < HUF_WORKSPACE_SIZE) return ERROR(workSpace_tooSmall);
	if (!srcSize) return 0; /* Uncompressed */
	if (!dstSize) return 0; /* cannot fit anything within dst budget */
	if (srcSize > HUF_BLOCKSIZE_MAX) return ERROR(srcSize_wrong); /* current block size limit */
	if (huffLog > HUF_TABLELOG_MAX) return ERROR(tableLog_tooLarge);
	if (maxSymbolValue > HUF_SYMBOLVALUE_MAX) return ERROR(maxSymbolValue_tooLarge);
	if (!maxSymbolValue) maxSymbolValue = HUF_SYMBOLVALUE_MAX;
	if (!huffLog) huffLog = HUF_TABLELOG_DEFAULT;

	/* Heuristic : If old table is valid, use it for small inputs */
	if (preferRepeat && repeat && *repeat == HUF_repeat_valid) {
	return HUF_compressCTable_internal(ostart, op, oend,
	src, srcSize,
	nbStreams, oldHufTable, bmi2);
	}

	/* Scan input and build symbol stats */
	{ CHECK_V_F(largest, HIST_count_wksp (table->count, &maxSymbolValue, (const BYTE*)src, srcSize, workSpace, wkspSize) );
	if (largest == srcSize) { ostart = ((const BYTE)src)[0]; return 1; } /* single symbol, rle */
	if (largest <= (srcSize >> 7)+4) return 0; /* heuristic : probably not compressible enough */
	}

	/* Check validity of previous table */
	if ( repeat
	&& *repeat == HUF_repeat_check
	&& !HUF_validateCTable(oldHufTable, table->count, maxSymbolValue)) {
	*repeat = HUF_repeat_none;
	}
	/* Heuristic : use existing table for small inputs */
	if (preferRepeat && repeat && *repeat != HUF_repeat_none) {
	return HUF_compressCTable_internal(ostart, op, oend,
	src, srcSize,
	nbStreams, oldHufTable, bmi2);
	}

	/* Build Huffman Tree */
	huffLog = HUF_optimalTableLog(huffLog, srcSize, maxSymbolValue);
	{ size_t const maxBits = HUF_buildCTable_wksp(table->CTable, table->count,
	maxSymbolValue, huffLog,
	&table->buildCTable_wksp, sizeof(table->buildCTable_wksp));
	CHECK_F(maxBits);
	huffLog = (U32)maxBits;
	/* Zero unused symbols in CTable, so we can check it for validity */
	memset(table->CTable + (maxSymbolValue + 1), 0,
	sizeof(table->CTable) - ((maxSymbolValue + 1) * sizeof(HUF_CElt)));
	}

	/* Write table description header */
	{ CHECK_V_F(hSize, HUF_writeCTable (op, dstSize, table->CTable, maxSymbolValue, huffLog) );
	/* Check if using previous huffman table is beneficial */
	if (repeat && *repeat != HUF_repeat_none) {
	size_t const oldSize = HUF_estimateCompressedSize(oldHufTable, table->count, maxSymbolValue);
	size_t const newSize = HUF_estimateCompressedSize(table->CTable, table->count, maxSymbolValue);
	if (oldSize <= hSize + newSize \|\| hSize + 12 >= srcSize) {
	return HUF_compressCTable_internal(ostart, op, oend,
	src, srcSize,
	nbStreams, oldHufTable, bmi2);
	} }

	/* Use the new huffman table */
	if (hSize + 12ul >= srcSize) { return 0; }
	op += hSize;
	if (repeat) { *repeat = HUF_repeat_none; }
	if (oldHufTable)
	memcpy(oldHufTable, table->CTable, sizeof(table->CTable)); /* Save new table */
	}
	return HUF_compressCTable_internal(ostart, op, oend,
	src, srcSize,
	nbStreams, table->CTable, bmi2);
	}


	size_t HUF_compress1X_wksp (void* dst, size_t dstSize,
	const void* src, size_t srcSize,
	unsigned maxSymbolValue, unsigned huffLog,
	void* workSpace, size_t wkspSize)
	{
	return HUF_compress_internal(dst, dstSize, src, srcSize,
	maxSymbolValue, huffLog, HUF_singleStream,
	workSpace, wkspSize,
	NULL, NULL, 0, 0 /bmi2/);
	}

	size_t HUF_compress1X_repeat (void* dst, size_t dstSize,
	const void* src, size_t srcSize,
	unsigned maxSymbolValue, unsigned huffLog,
	void* workSpace, size_t wkspSize,
	HUF_CElt* hufTable, HUF_repeat* repeat, int preferRepeat, int bmi2)
	{
	return HUF_compress_internal(dst, dstSize, src, srcSize,
	maxSymbolValue, huffLog, HUF_singleStream,
	workSpace, wkspSize, hufTable,
	repeat, preferRepeat, bmi2);
	}

	size_t HUF_compress1X (void* dst, size_t dstSize,
	const void* src, size_t srcSize,
	unsigned maxSymbolValue, unsigned huffLog)
	{
	unsigned workSpace[HUF_WORKSPACE_SIZE_U32];
	return HUF_compress1X_wksp(dst, dstSize, src, srcSize, maxSymbolValue, huffLog, workSpace, sizeof(workSpace));
	}

	/* HUF_compress4X_repeat():
	* compress input using 4 streams.
	* provide workspace to generate compression tables */
	size_t HUF_compress4X_wksp (void* dst, size_t dstSize,
	const void* src, size_t srcSize,
	unsigned maxSymbolValue, unsigned huffLog,
	void* workSpace, size_t wkspSize)
	{
	return HUF_compress_internal(dst, dstSize, src, srcSize,
	maxSymbolValue, huffLog, HUF_fourStreams,
	workSpace, wkspSize,
	NULL, NULL, 0, 0 /bmi2/);
	}

	/* HUF_compress4X_repeat():
	* compress input using 4 streams.
	* re-use an existing huffman compression table */
	size_t HUF_compress4X_repeat (void* dst, size_t dstSize,
	const void* src, size_t srcSize,
	unsigned maxSymbolValue, unsigned huffLog,
	void* workSpace, size_t wkspSize,
	HUF_CElt* hufTable, HUF_repeat* repeat, int preferRepeat, int bmi2)
	{
	return HUF_compress_internal(dst, dstSize, src, srcSize,
	maxSymbolValue, huffLog, HUF_fourStreams,
	workSpace, wkspSize,
	hufTable, repeat, preferRepeat, bmi2);
	}

	size_t HUF_compress2 (void* dst, size_t dstSize,
	const void* src, size_t srcSize,
	unsigned maxSymbolValue, unsigned huffLog)
	{
	unsigned workSpace[HUF_WORKSPACE_SIZE_U32];
	return HUF_compress4X_wksp(dst, dstSize, src, srcSize, maxSymbolValue, huffLog, workSpace, sizeof(workSpace));
	}

	size_t HUF_compress (void* dst, size_t maxDstSize, const void* src, size_t srcSize)
	{
	return HUF_compress2(dst, maxDstSize, src, srcSize, 255, HUF_TABLELOG_DEFAULT);
	}
	/** ended inlining compress/huf_compress.c **/
	/** start inlining compress/zstd_compress_literals.c **/
	/*
	* Copyright (c) 2016-2020, Yann Collet, Facebook, Inc.
	* All rights reserved.
	*
	* This source code is licensed under both the BSD-style license (found in the
	* LICENSE file in the root directory of this source tree) and the GPLv2 (found
	* in the COPYING file in the root directory of this source tree).
	* You may select, at your option, one of the above-listed licenses.
	*/

	/-************************************
	* Dependencies
	***************************************/
	/** start inlining zstd_compress_literals.h **/
	/*
	* Copyright (c) 2016-2020, Yann Collet, Facebook, Inc.
	* All rights reserved.
	*
	* This source code is licensed under both the BSD-style license (found in the
	* LICENSE file in the root directory of this source tree) and the GPLv2 (found
	* in the COPYING file in the root directory of this source tree).
	* You may select, at your option, one of the above-listed licenses.
	*/

	#ifndef ZSTD_COMPRESS_LITERALS_H
	#define ZSTD_COMPRESS_LITERALS_H

	/** start inlining zstd_compress_internal.h **/
	/*
	* Copyright (c) 2016-2020, Yann Collet, Facebook, Inc.
	* All rights reserved.
	*
	* This source code is licensed under both the BSD-style license (found in the
	* LICENSE file in the root directory of this source tree) and the GPLv2 (found
	* in the COPYING file in the root directory of this source tree).
	* You may select, at your option, one of the above-listed licenses.
	*/

	/* This header contains definitions
	* that shall only be used by modules within lib/compress.
	*/

	#ifndef ZSTD_COMPRESS_H
	#define ZSTD_COMPRESS_H

	/-************************************
	* Dependencies
	***************************************/
	/** skipping file: ../common/zstd_internal.h **/
	/** start inlining zstd_cwksp.h **/
	/*
	* Copyright (c) 2016-2020, Yann Collet, Facebook, Inc.
	* All rights reserved.
	*
	* This source code is licensed under both the BSD-style license (found in the
	* LICENSE file in the root directory of this source tree) and the GPLv2 (found
	* in the COPYING file in the root directory of this source tree).
	* You may select, at your option, one of the above-listed licenses.
	*/

	#ifndef ZSTD_CWKSP_H
	#define ZSTD_CWKSP_H

	/-************************************
	* Dependencies
	***************************************/
	/** skipping file: ../common/zstd_internal.h **/

	#if defined (__cplusplus)
	extern "C" {
	#endif

	/-************************************
	* Constants
	***************************************/

	/* Since the workspace is effectively its own little malloc implementation /
	* arena, when we run under ASAN, we should similarly insert redzones between
	* each internal element of the workspace, so ASAN will catch overruns that
	* reach outside an object but that stay inside the workspace.
	*
	* This defines the size of that redzone.
	*/
	#ifndef ZSTD_CWKSP_ASAN_REDZONE_SIZE
	#define ZSTD_CWKSP_ASAN_REDZONE_SIZE 128
	#endif

	/-************************************
	* Structures
	***************************************/
	typedef enum {
	ZSTD_cwksp_alloc_objects,
	ZSTD_cwksp_alloc_buffers,
	ZSTD_cwksp_alloc_aligned
	} ZSTD_cwksp_alloc_phase_e;

	/**
	* Zstd fits all its internal datastructures into a single continuous buffer,
	* so that it only needs to perform a single OS allocation (or so that a buffer
	* can be provided to it and it can perform no allocations at all). This buffer
	* is called the workspace.
	*
	* Several optimizations complicate that process of allocating memory ranges
	* from this workspace for each internal datastructure:
	*
	* - These different internal datastructures have different setup requirements:
	*
	* - The static objects need to be cleared once and can then be trivially
	* reused for each compression.
	*
	* - Various buffers don't need to be initialized at all--they are always
	* written into before they're read.
	*
	* - The matchstate tables have a unique requirement that they don't need
	* their memory to be totally cleared, but they do need the memory to have
	* some bound, i.e., a guarantee that all values in the memory they've been
	* allocated is less than some maximum value (which is the starting value
	* for the indices that they will then use for compression). When this
	* guarantee is provided to them, they can use the memory without any setup
	* work. When it can't, they have to clear the area.
	*
	* - These buffers also have different alignment requirements.
	*
	* - We would like to reuse the objects in the workspace for multiple
	* compressions without having to perform any expensive reallocation or
	* reinitialization work.
	*
	* - We would like to be able to efficiently reuse the workspace across
	* multiple compressions even when the compression parameters change and
	* we need to resize some of the objects (where possible).
	*
	* To attempt to manage this buffer, given these constraints, the ZSTD_cwksp
	* abstraction was created. It works as follows:
	*
	* Workspace Layout:
	*
	* [ ... workspace ... ]
	* [objects][tables ... ->] free space [<- ... aligned][<- ... buffers]
	*
	* The various objects that live in the workspace are divided into the
	* following categories, and are allocated separately:
	*
	* - Static objects: this is optionally the enclosing ZSTD_CCtx or ZSTD_CDict,
	* so that literally everything fits in a single buffer. Note: if present,
	* this must be the first object in the workspace, since ZSTD_free{CCtx,
	* CDict}() rely on a pointer comparison to see whether one or two frees are
	* required.
	*
	* - Fixed size objects: these are fixed-size, fixed-count objects that are
	* nonetheless "dynamically" allocated in the workspace so that we can
	* control how they're initialized separately from the broader ZSTD_CCtx.
	* Examples:
	* - Entropy Workspace
	* - 2 x ZSTD_compressedBlockState_t
	* - CDict dictionary contents
	*
	* - Tables: these are any of several different datastructures (hash tables,
	* chain tables, binary trees) that all respect a common format: they are
	* uint32_t arrays, all of whose values are between 0 and (nextSrc - base).
	* Their sizes depend on the cparams.
	*
	* - Aligned: these buffers are used for various purposes that require 4 byte
	* alignment, but don't require any initialization before they're used.
	*
	* - Buffers: these buffers are used for various purposes that don't require
	* any alignment or initialization before they're used. This means they can
	* be moved around at no cost for a new compression.
	*
	* Allocating Memory:
	*
	* The various types of objects must be allocated in order, so they can be
	* correctly packed into the workspace buffer. That order is:
	*
	* 1. Objects
	* 2. Buffers
	* 3. Aligned
	* 4. Tables
	*
	* Attempts to reserve objects of different types out of order will fail.
	*/
	typedef struct {
	void* workspace;
	void* workspaceEnd;

	void* objectEnd;
	void* tableEnd;
	void* tableValidEnd;
	void* allocStart;

	int allocFailed;
	int workspaceOversizedDuration;
	ZSTD_cwksp_alloc_phase_e phase;
	} ZSTD_cwksp;

	/-************************************
	* Functions
	***************************************/

	MEM_STATIC size_t ZSTD_cwksp_available_space(ZSTD_cwksp* ws);

	MEM_STATIC void ZSTD_cwksp_assert_internal_consistency(ZSTD_cwksp* ws) {
	(void)ws;
	assert(ws->workspace <= ws->objectEnd);
	assert(ws->objectEnd <= ws->tableEnd);
	assert(ws->objectEnd <= ws->tableValidEnd);
	assert(ws->tableEnd <= ws->allocStart);
	assert(ws->tableValidEnd <= ws->allocStart);
	assert(ws->allocStart <= ws->workspaceEnd);
	}

	/**
	* Align must be a power of 2.
	*/
	MEM_STATIC size_t ZSTD_cwksp_align(size_t size, size_t const align) {
	size_t const mask = align - 1;
	assert((align & mask) == 0);
	return (size + mask) & ~mask;
	}

	/**
	* Use this to determine how much space in the workspace we will consume to
	* allocate this object. (Normally it should be exactly the size of the object,
	* but under special conditions, like ASAN, where we pad each object, it might
	* be larger.)
	*
	* Since tables aren't currently redzoned, you don't need to call through this
	* to figure out how much space you need for the matchState tables. Everything
	* else is though.
	*/
	MEM_STATIC size_t ZSTD_cwksp_alloc_size(size_t size) {
	#if defined (ADDRESS_SANITIZER) && !defined (ZSTD_ASAN_DONT_POISON_WORKSPACE)
	return size + 2 * ZSTD_CWKSP_ASAN_REDZONE_SIZE;
	#else
	return size;
	#endif
	}

	MEM_STATIC void ZSTD_cwksp_internal_advance_phase(
	ZSTD_cwksp* ws, ZSTD_cwksp_alloc_phase_e phase) {
	assert(phase >= ws->phase);
	if (phase > ws->phase) {
	if (ws->phase < ZSTD_cwksp_alloc_buffers &&
	phase >= ZSTD_cwksp_alloc_buffers) {
	ws->tableValidEnd = ws->objectEnd;
	}
	if (ws->phase < ZSTD_cwksp_alloc_aligned &&
	phase >= ZSTD_cwksp_alloc_aligned) {
	/* If unaligned allocations down from a too-large top have left us
	* unaligned, we need to realign our alloc ptr. Technically, this
	* can consume space that is unaccounted for in the neededSpace
	* calculation. However, I believe this can only happen when the
	* workspace is too large, and specifically when it is too large
	* by a larger margin than the space that will be consumed. */
	/* TODO: cleaner, compiler warning friendly way to do this??? */
	ws->allocStart = (BYTE*)ws->allocStart - ((size_t)ws->allocStart & (sizeof(U32)-1));
	if (ws->allocStart < ws->tableValidEnd) {
	ws->tableValidEnd = ws->allocStart;
	}
	}
	ws->phase = phase;
	}
	}

	/**
	* Returns whether this object/buffer/etc was allocated in this workspace.
	*/
	MEM_STATIC int ZSTD_cwksp_owns_buffer(const ZSTD_cwksp* ws, const void* ptr) {
	return (ptr != NULL) && (ws->workspace <= ptr) && (ptr <= ws->workspaceEnd);
	}

	/**
	* Internal function. Do not use directly.
	*/
	MEM_STATIC void* ZSTD_cwksp_reserve_internal(
	ZSTD_cwksp* ws, size_t bytes, ZSTD_cwksp_alloc_phase_e phase) {
	void* alloc;
	void* bottom = ws->tableEnd;
	ZSTD_cwksp_internal_advance_phase(ws, phase);
	alloc = (BYTE *)ws->allocStart - bytes;

	#if defined (ADDRESS_SANITIZER) && !defined (ZSTD_ASAN_DONT_POISON_WORKSPACE)
	/* over-reserve space */
	alloc = (BYTE )alloc - 2 ZSTD_CWKSP_ASAN_REDZONE_SIZE;
	#endif

	DEBUGLOG(5, "cwksp: reserving %p %zd bytes, %zd bytes remaining",
	alloc, bytes, ZSTD_cwksp_available_space(ws) - bytes);
	ZSTD_cwksp_assert_internal_consistency(ws);
	assert(alloc >= bottom);
	if (alloc < bottom) {
	DEBUGLOG(4, "cwksp: alloc failed!");
	ws->allocFailed = 1;
	return NULL;
	}
	if (alloc < ws->tableValidEnd) {
	ws->tableValidEnd = alloc;
	}
	ws->allocStart = alloc;

	#if defined (ADDRESS_SANITIZER) && !defined (ZSTD_ASAN_DONT_POISON_WORKSPACE)
	/* Move alloc so there's ZSTD_CWKSP_ASAN_REDZONE_SIZE unused space on
	* either size. */
	alloc = (BYTE *)alloc + ZSTD_CWKSP_ASAN_REDZONE_SIZE;
	__asan_unpoison_memory_region(alloc, bytes);
	#endif

	return alloc;
	}

	/**
	* Reserves and returns unaligned memory.
	*/
	MEM_STATIC BYTE* ZSTD_cwksp_reserve_buffer(ZSTD_cwksp* ws, size_t bytes) {
	return (BYTE*)ZSTD_cwksp_reserve_internal(ws, bytes, ZSTD_cwksp_alloc_buffers);
	}

	/**
	* Reserves and returns memory sized on and aligned on sizeof(unsigned).
	*/
	MEM_STATIC void* ZSTD_cwksp_reserve_aligned(ZSTD_cwksp* ws, size_t bytes) {
	assert((bytes & (sizeof(U32)-1)) == 0);
	return ZSTD_cwksp_reserve_internal(ws, ZSTD_cwksp_align(bytes, sizeof(U32)), ZSTD_cwksp_alloc_aligned);
	}

	/**
	* Aligned on sizeof(unsigned). These buffers have the special property that
	* their values remain constrained, allowing us to re-use them without
	* memset()-ing them.
	*/
	MEM_STATIC void* ZSTD_cwksp_reserve_table(ZSTD_cwksp* ws, size_t bytes) {
	const ZSTD_cwksp_alloc_phase_e phase = ZSTD_cwksp_alloc_aligned;
	void* alloc = ws->tableEnd;
	void* end = (BYTE *)alloc + bytes;
	void* top = ws->allocStart;

	DEBUGLOG(5, "cwksp: reserving %p table %zd bytes, %zd bytes remaining",
	alloc, bytes, ZSTD_cwksp_available_space(ws) - bytes);
	assert((bytes & (sizeof(U32)-1)) == 0);
	ZSTD_cwksp_internal_advance_phase(ws, phase);
	ZSTD_cwksp_assert_internal_consistency(ws);
	assert(end <= top);
	if (end > top) {
	DEBUGLOG(4, "cwksp: table alloc failed!");
	ws->allocFailed = 1;
	return NULL;
	}
	ws->tableEnd = end;

	#if defined (ADDRESS_SANITIZER) && !defined (ZSTD_ASAN_DONT_POISON_WORKSPACE)
	__asan_unpoison_memory_region(alloc, bytes);
	#endif

	return alloc;
	}

	/**
	* Aligned on sizeof(void*).
	*/
	MEM_STATIC void* ZSTD_cwksp_reserve_object(ZSTD_cwksp* ws, size_t bytes) {
	size_t roundedBytes = ZSTD_cwksp_align(bytes, sizeof(void*));
	void* alloc = ws->objectEnd;
	void* end = (BYTE*)alloc + roundedBytes;

	#if defined (ADDRESS_SANITIZER) && !defined (ZSTD_ASAN_DONT_POISON_WORKSPACE)
	/* over-reserve space */
	end = (BYTE )end + 2 ZSTD_CWKSP_ASAN_REDZONE_SIZE;
	#endif

	DEBUGLOG(5,
	"cwksp: reserving %p object %zd bytes (rounded to %zd), %zd bytes remaining",
	alloc, bytes, roundedBytes, ZSTD_cwksp_available_space(ws) - roundedBytes);
	assert(((size_t)alloc & (sizeof(void*)-1)) == 0);
	assert((bytes & (sizeof(void*)-1)) == 0);
	ZSTD_cwksp_assert_internal_consistency(ws);
	/* we must be in the first phase, no advance is possible */
	if (ws->phase != ZSTD_cwksp_alloc_objects \|\| end > ws->workspaceEnd) {
	DEBUGLOG(4, "cwksp: object alloc failed!");
	ws->allocFailed = 1;
	return NULL;
	}
	ws->objectEnd = end;
	ws->tableEnd = end;
	ws->tableValidEnd = end;

	#if defined (ADDRESS_SANITIZER) && !defined (ZSTD_ASAN_DONT_POISON_WORKSPACE)
	/* Move alloc so there's ZSTD_CWKSP_ASAN_REDZONE_SIZE unused space on
	* either size. */
	alloc = (BYTE *)alloc + ZSTD_CWKSP_ASAN_REDZONE_SIZE;
	__asan_unpoison_memory_region(alloc, bytes);
	#endif

	return alloc;
	}

	MEM_STATIC void ZSTD_cwksp_mark_tables_dirty(ZSTD_cwksp* ws) {
	DEBUGLOG(4, "cwksp: ZSTD_cwksp_mark_tables_dirty");

	#if defined (MEMORY_SANITIZER) && !defined (ZSTD_MSAN_DONT_POISON_WORKSPACE)
	/* To validate that the table re-use logic is sound, and that we don't
	* access table space that we haven't cleaned, we re-"poison" the table
	* space every time we mark it dirty. */
	{
	size_t size = (BYTE)ws->tableValidEnd - (BYTE)ws->objectEnd;
	assert(__msan_test_shadow(ws->objectEnd, size) == -1);
	__msan_poison(ws->objectEnd, size);
	}
	#endif

	assert(ws->tableValidEnd >= ws->objectEnd);
	assert(ws->tableValidEnd <= ws->allocStart);
	ws->tableValidEnd = ws->objectEnd;
	ZSTD_cwksp_assert_internal_consistency(ws);
	}

	MEM_STATIC void ZSTD_cwksp_mark_tables_clean(ZSTD_cwksp* ws) {
	DEBUGLOG(4, "cwksp: ZSTD_cwksp_mark_tables_clean");
	assert(ws->tableValidEnd >= ws->objectEnd);
	assert(ws->tableValidEnd <= ws->allocStart);
	if (ws->tableValidEnd < ws->tableEnd) {
	ws->tableValidEnd = ws->tableEnd;
	}
	ZSTD_cwksp_assert_internal_consistency(ws);
	}

	/**
	* Zero the part of the allocated tables not already marked clean.
	*/
	MEM_STATIC void ZSTD_cwksp_clean_tables(ZSTD_cwksp* ws) {
	DEBUGLOG(4, "cwksp: ZSTD_cwksp_clean_tables");
	assert(ws->tableValidEnd >= ws->objectEnd);
	assert(ws->tableValidEnd <= ws->allocStart);
	if (ws->tableValidEnd < ws->tableEnd) {
	memset(ws->tableValidEnd, 0, (BYTE)ws->tableEnd - (BYTE)ws->tableValidEnd);
	}
	ZSTD_cwksp_mark_tables_clean(ws);
	}

	/**
	* Invalidates table allocations.
	* All other allocations remain valid.
	*/
	MEM_STATIC void ZSTD_cwksp_clear_tables(ZSTD_cwksp* ws) {
	DEBUGLOG(4, "cwksp: clearing tables!");

	#if defined (ADDRESS_SANITIZER) && !defined (ZSTD_ASAN_DONT_POISON_WORKSPACE)
	{
	size_t size = (BYTE)ws->tableValidEnd - (BYTE)ws->objectEnd;
	__asan_poison_memory_region(ws->objectEnd, size);
	}
	#endif

	ws->tableEnd = ws->objectEnd;
	ZSTD_cwksp_assert_internal_consistency(ws);
	}

	/**
	* Invalidates all buffer, aligned, and table allocations.
	* Object allocations remain valid.
	*/
	MEM_STATIC void ZSTD_cwksp_clear(ZSTD_cwksp* ws) {
	DEBUGLOG(4, "cwksp: clearing!");

	#if defined (MEMORY_SANITIZER) && !defined (ZSTD_MSAN_DONT_POISON_WORKSPACE)
	/* To validate that the context re-use logic is sound, and that we don't
	* access stuff that this compression hasn't initialized, we re-"poison"
	* the workspace (or at least the non-static, non-table parts of it)
	* every time we start a new compression. */
	{
	size_t size = (BYTE)ws->workspaceEnd - (BYTE)ws->tableValidEnd;
	__msan_poison(ws->tableValidEnd, size);
	}
	#endif

	#if defined (ADDRESS_SANITIZER) && !defined (ZSTD_ASAN_DONT_POISON_WORKSPACE)
	{
	size_t size = (BYTE)ws->workspaceEnd - (BYTE)ws->objectEnd;
	__asan_poison_memory_region(ws->objectEnd, size);
	}
	#endif

	ws->tableEnd = ws->objectEnd;
	ws->allocStart = ws->workspaceEnd;
	ws->allocFailed = 0;
	if (ws->phase > ZSTD_cwksp_alloc_buffers) {
	ws->phase = ZSTD_cwksp_alloc_buffers;
	}
	ZSTD_cwksp_assert_internal_consistency(ws);
	}

	/**
	* The provided workspace takes ownership of the buffer [start, start+size).
	* Any existing values in the workspace are ignored (the previously managed
	* buffer, if present, must be separately freed).
	*/
	MEM_STATIC void ZSTD_cwksp_init(ZSTD_cwksp* ws, void* start, size_t size) {
	DEBUGLOG(4, "cwksp: init'ing workspace with %zd bytes", size);
	assert(((size_t)start & (sizeof(void)-1)) == 0); / ensure correct alignment */
	ws->workspace = start;
	ws->workspaceEnd = (BYTE*)start + size;
	ws->objectEnd = ws->workspace;
	ws->tableValidEnd = ws->objectEnd;
	ws->phase = ZSTD_cwksp_alloc_objects;
	ZSTD_cwksp_clear(ws);
	ws->workspaceOversizedDuration = 0;
	ZSTD_cwksp_assert_internal_consistency(ws);
	}

	MEM_STATIC size_t ZSTD_cwksp_create(ZSTD_cwksp* ws, size_t size, ZSTD_customMem customMem) {
	void* workspace = ZSTD_malloc(size, customMem);
	DEBUGLOG(4, "cwksp: creating new workspace with %zd bytes", size);
	RETURN_ERROR_IF(workspace == NULL, memory_allocation, "NULL pointer!");
	ZSTD_cwksp_init(ws, workspace, size);
	return 0;
	}

	MEM_STATIC void ZSTD_cwksp_free(ZSTD_cwksp* ws, ZSTD_customMem customMem) {
	void *ptr = ws->workspace;
	DEBUGLOG(4, "cwksp: freeing workspace");
	memset(ws, 0, sizeof(ZSTD_cwksp));
	ZSTD_free(ptr, customMem);
	}

	/**
	* Moves the management of a workspace from one cwksp to another. The src cwksp
	* is left in an invalid state (src must be re-init()'ed before its used again).
	*/
	MEM_STATIC void ZSTD_cwksp_move(ZSTD_cwksp* dst, ZSTD_cwksp* src) {
	dst = src;
	memset(src, 0, sizeof(ZSTD_cwksp));
	}

	MEM_STATIC size_t ZSTD_cwksp_sizeof(const ZSTD_cwksp* ws) {
	return (size_t)((BYTE)ws->workspaceEnd - (BYTE)ws->workspace);
	}

	MEM_STATIC int ZSTD_cwksp_reserve_failed(const ZSTD_cwksp* ws) {
	return ws->allocFailed;
	}

	/-************************************
	* Functions Checking Free Space
	***************************************/

	MEM_STATIC size_t ZSTD_cwksp_available_space(ZSTD_cwksp* ws) {
	return (size_t)((BYTE)ws->allocStart - (BYTE)ws->tableEnd);
	}

	MEM_STATIC int ZSTD_cwksp_check_available(ZSTD_cwksp* ws, size_t additionalNeededSpace) {
	return ZSTD_cwksp_available_space(ws) >= additionalNeededSpace;
	}

	MEM_STATIC int ZSTD_cwksp_check_too_large(ZSTD_cwksp* ws, size_t additionalNeededSpace) {
	return ZSTD_cwksp_check_available(
	ws, additionalNeededSpace * ZSTD_WORKSPACETOOLARGE_FACTOR);
	}

	MEM_STATIC int ZSTD_cwksp_check_wasteful(ZSTD_cwksp* ws, size_t additionalNeededSpace) {
	return ZSTD_cwksp_check_too_large(ws, additionalNeededSpace)
	&& ws->workspaceOversizedDuration > ZSTD_WORKSPACETOOLARGE_MAXDURATION;
	}

	MEM_STATIC void ZSTD_cwksp_bump_oversized_duration(
	ZSTD_cwksp* ws, size_t additionalNeededSpace) {
	if (ZSTD_cwksp_check_too_large(ws, additionalNeededSpace)) {
	ws->workspaceOversizedDuration++;
	} else {
	ws->workspaceOversizedDuration = 0;
	}
	}

	#if defined (__cplusplus)
	}
	#endif

	#endif /* ZSTD_CWKSP_H */
	/** ended inlining zstd_cwksp.h **/
	#ifdef ZSTD_MULTITHREAD
	/** start inlining zstdmt_compress.h **/
	/*
	* Copyright (c) 2016-2020, Yann Collet, Facebook, Inc.
	* All rights reserved.
	*
	* This source code is licensed under both the BSD-style license (found in the
	* LICENSE file in the root directory of this source tree) and the GPLv2 (found
	* in the COPYING file in the root directory of this source tree).
	* You may select, at your option, one of the above-listed licenses.
	*/

	#ifndef ZSTDMT_COMPRESS_H
	#define ZSTDMT_COMPRESS_H

	#if defined (__cplusplus)
	extern "C" {
	#endif


	/* Note : This is an internal API.
	* These APIs used to be exposed with ZSTDLIB_API,
	* because it used to be the only way to invoke MT compression.
	* Now, it's recommended to use ZSTD_compress2 and ZSTD_compressStream2()
	* instead.
	*
	* If you depend on these APIs and can't switch, then define
	* ZSTD_LEGACY_MULTITHREADED_API when making the dynamic library.
	* However, we may completely remove these functions in a future
	* release, so please switch soon.
	*
	* This API requires ZSTD_MULTITHREAD to be defined during compilation,
	* otherwise ZSTDMT_createCCtx*() will fail.
	*/

	#ifdef ZSTD_LEGACY_MULTITHREADED_API
	# define ZSTDMT_API ZSTDLIB_API
	#else
	# define ZSTDMT_API
	#endif

	/* === Dependencies === */
	#include <stddef.h> /* size_t */
	#define ZSTD_STATIC_LINKING_ONLY /* ZSTD_parameters */
	/** skipping file: ../zstd.h **/


	/* === Constants === */
	#ifndef ZSTDMT_NBWORKERS_MAX
	# define ZSTDMT_NBWORKERS_MAX 200
	#endif
	#ifndef ZSTDMT_JOBSIZE_MIN
	# define ZSTDMT_JOBSIZE_MIN (1 MB)
	#endif
	#define ZSTDMT_JOBLOG_MAX (MEM_32bits() ? 29 : 30)
	#define ZSTDMT_JOBSIZE_MAX (MEM_32bits() ? (512 MB) : (1024 MB))


	/* === Memory management === */
	typedef struct ZSTDMT_CCtx_s ZSTDMT_CCtx;
	/* Requires ZSTD_MULTITHREAD to be defined during compilation, otherwise it will return NULL. */
	ZSTDMT_API ZSTDMT_CCtx* ZSTDMT_createCCtx(unsigned nbWorkers);
	/* Requires ZSTD_MULTITHREAD to be defined during compilation, otherwise it will return NULL. */
	ZSTDMT_API ZSTDMT_CCtx* ZSTDMT_createCCtx_advanced(unsigned nbWorkers,
	ZSTD_customMem cMem);
	ZSTDMT_API size_t ZSTDMT_freeCCtx(ZSTDMT_CCtx* mtctx);

	ZSTDMT_API size_t ZSTDMT_sizeof_CCtx(ZSTDMT_CCtx* mtctx);


	/* === Simple one-pass compression function === */

	ZSTDMT_API size_t ZSTDMT_compressCCtx(ZSTDMT_CCtx* mtctx,
	void* dst, size_t dstCapacity,
	const void* src, size_t srcSize,
	int compressionLevel);



	/* === Streaming functions === */

	ZSTDMT_API size_t ZSTDMT_initCStream(ZSTDMT_CCtx* mtctx, int compressionLevel);
	ZSTDMT_API size_t ZSTDMT_resetCStream(ZSTDMT_CCtx* mtctx, unsigned long long pledgedSrcSize); /*< if srcSize is not known at reset time, use ZSTD_CONTENTSIZE_UNKNOWN. Note: for compatibility with older programs, 0 means the same as ZSTD_CONTENTSIZE_UNKNOWN, but it will change in the future to mean "empty" /

	ZSTDMT_API size_t ZSTDMT_nextInputSizeHint(const ZSTDMT_CCtx* mtctx);
	ZSTDMT_API size_t ZSTDMT_compressStream(ZSTDMT_CCtx* mtctx, ZSTD_outBuffer* output, ZSTD_inBuffer* input);

	ZSTDMT_API size_t ZSTDMT_flushStream(ZSTDMT_CCtx* mtctx, ZSTD_outBuffer* output); /*< @return : 0 == all flushed; >0 : still some data to be flushed; or an error code (ZSTD_isError()) /
	ZSTDMT_API size_t ZSTDMT_endStream(ZSTDMT_CCtx* mtctx, ZSTD_outBuffer* output); /*< @return : 0 == all flushed; >0 : still some data to be flushed; or an error code (ZSTD_isError()) /


	/* === Advanced functions and parameters === */

	ZSTDMT_API size_t ZSTDMT_compress_advanced(ZSTDMT_CCtx* mtctx,
	void* dst, size_t dstCapacity,
	const void* src, size_t srcSize,
	const ZSTD_CDict* cdict,
	ZSTD_parameters params,
	int overlapLog);

	ZSTDMT_API size_t ZSTDMT_initCStream_advanced(ZSTDMT_CCtx* mtctx,
	const void* dict, size_t dictSize, /* dict can be released after init, a local copy is preserved within zcs */
	ZSTD_parameters params,
	unsigned long long pledgedSrcSize); /* pledgedSrcSize is optional and can be zero == unknown */

	ZSTDMT_API size_t ZSTDMT_initCStream_usingCDict(ZSTDMT_CCtx* mtctx,
	const ZSTD_CDict* cdict,
	ZSTD_frameParameters fparams,
	unsigned long long pledgedSrcSize); /* note : zero means empty */

	/* ZSTDMT_parameter :
	* List of parameters that can be set using ZSTDMT_setMTCtxParameter() */
	typedef enum {
	ZSTDMT_p_jobSize, /* Each job is compressed in parallel. By default, this value is dynamically determined depending on compression parameters. Can be set explicitly here. */
	ZSTDMT_p_overlapLog, /* Each job may reload a part of previous job to enhance compression ratio; 0 == no overlap, 6(default) == use 1/8th of window, >=9 == use full window. This is a "sticky" parameter : its value will be re-used on next compression job */
	ZSTDMT_p_rsyncable /* Enables rsyncable mode. */
	} ZSTDMT_parameter;

	/* ZSTDMT_setMTCtxParameter() :
	* allow setting individual parameters, one at a time, among a list of enums defined in ZSTDMT_parameter.
	* The function must be called typically after ZSTD_createCCtx() but __before ZSTDMT_init*() !__
	* Parameters not explicitly reset by ZSTDMT_init*() remain the same in consecutive compression sessions.
	* @return : 0, or an error code (which can be tested using ZSTD_isError()) */
	ZSTDMT_API size_t ZSTDMT_setMTCtxParameter(ZSTDMT_CCtx* mtctx, ZSTDMT_parameter parameter, int value);

	/* ZSTDMT_getMTCtxParameter() :
	* Query the ZSTDMT_CCtx for a parameter value.
	* @return : 0, or an error code (which can be tested using ZSTD_isError()) */
	ZSTDMT_API size_t ZSTDMT_getMTCtxParameter(ZSTDMT_CCtx* mtctx, ZSTDMT_parameter parameter, int* value);


	/*! ZSTDMT_compressStream_generic() :
	* Combines ZSTDMT_compressStream() with optional ZSTDMT_flushStream() or ZSTDMT_endStream()
	* depending on flush directive.
	* @return : minimum amount of data still to be flushed
	* 0 if fully flushed
	* or an error code
	* note : needs to be init using any ZSTD_initCStream() variant /
	ZSTDMT_API size_t ZSTDMT_compressStream_generic(ZSTDMT_CCtx* mtctx,
	ZSTD_outBuffer* output,
	ZSTD_inBuffer* input,
	ZSTD_EndDirective endOp);


	/* ========================================================
	* === Private interface, for use by ZSTD_compress.c ===
	* === Not exposed in libzstd. Never invoke directly ===
	* ======================================================== */

	/*! ZSTDMT_toFlushNow()
	* Tell how many bytes are ready to be flushed immediately.
	* Probe the oldest active job (not yet entirely flushed) and check its output buffer.
	* If return 0, it means there is no active job,
	* or, it means oldest job is still active, but everything produced has been flushed so far,
	* therefore flushing is limited by speed of oldest job. */
	size_t ZSTDMT_toFlushNow(ZSTDMT_CCtx* mtctx);

	/*! ZSTDMT_CCtxParam_setMTCtxParameter()
	* like ZSTDMT_setMTCtxParameter(), but into a ZSTD_CCtx_Params */
	size_t ZSTDMT_CCtxParam_setMTCtxParameter(ZSTD_CCtx_params* params, ZSTDMT_parameter parameter, int value);

	/*! ZSTDMT_CCtxParam_setNbWorkers()
	* Set nbWorkers, and clamp it.
	* Also reset jobSize and overlapLog */
	size_t ZSTDMT_CCtxParam_setNbWorkers(ZSTD_CCtx_params* params, unsigned nbWorkers);

	/*! ZSTDMT_updateCParams_whileCompressing() :
	* Updates only a selected set of compression parameters, to remain compatible with current frame.
	* New parameters will be applied to next compression job. */
	void ZSTDMT_updateCParams_whileCompressing(ZSTDMT_CCtx* mtctx, const ZSTD_CCtx_params* cctxParams);

	/*! ZSTDMT_getFrameProgression():
	* tells how much data has been consumed (input) and produced (output) for current frame.
	* able to count progression inside worker threads.
	*/
	ZSTD_frameProgression ZSTDMT_getFrameProgression(ZSTDMT_CCtx* mtctx);


	/*! ZSTDMT_initCStream_internal() :
	* Private use only. Init streaming operation.
	* expects params to be valid.
	* must receive dict, or cdict, or none, but not both.
	* @return : 0, or an error code */
	size_t ZSTDMT_initCStream_internal(ZSTDMT_CCtx* zcs,
	const void* dict, size_t dictSize, ZSTD_dictContentType_e dictContentType,
	const ZSTD_CDict* cdict,
	ZSTD_CCtx_params params, unsigned long long pledgedSrcSize);


	#if defined (__cplusplus)
	}
	#endif

	#endif /* ZSTDMT_COMPRESS_H */
	/** ended inlining zstdmt_compress.h **/
	#endif

	#if defined (__cplusplus)
	extern "C" {
	#endif


	/-************************************
	* Constants
	***************************************/
	#define kSearchStrength 8
	#define HASH_READ_SIZE 8
	#define ZSTD_DUBT_UNSORTED_MARK 1 /* For btlazy2 strategy, index ZSTD_DUBT_UNSORTED_MARK==1 means "unsorted".
	It could be confused for a real successor at index "1", if sorted as larger than its predecessor.
	It's not a big deal though : candidate will just be sorted again.
	Additionally, candidate position 1 will be lost.
	But candidate 1 cannot hide a large tree of candidates, so it's a minimal loss.
	The benefit is that ZSTD_DUBT_UNSORTED_MARK cannot be mishandled after table re-use with a different strategy.
	This constant is required by ZSTD_compressBlock_btlazy2() and ZSTD_reduceTable_internal() */


	/-************************************
	* Context memory management
	***************************************/
	typedef enum { ZSTDcs_created=0, ZSTDcs_init, ZSTDcs_ongoing, ZSTDcs_ending } ZSTD_compressionStage_e;
	typedef enum { zcss_init=0, zcss_load, zcss_flush } ZSTD_cStreamStage;

	typedef struct ZSTD_prefixDict_s {
	const void* dict;
	size_t dictSize;
	ZSTD_dictContentType_e dictContentType;
	} ZSTD_prefixDict;

	typedef struct {
	void* dictBuffer;
	void const* dict;
	size_t dictSize;
	ZSTD_dictContentType_e dictContentType;
	ZSTD_CDict* cdict;
	} ZSTD_localDict;

	typedef struct {
	U32 CTable[HUF_CTABLE_SIZE_U32(255)];
	HUF_repeat repeatMode;
	} ZSTD_hufCTables_t;

	typedef struct {
	FSE_CTable offcodeCTable[FSE_CTABLE_SIZE_U32(OffFSELog, MaxOff)];
	FSE_CTable matchlengthCTable[FSE_CTABLE_SIZE_U32(MLFSELog, MaxML)];
	FSE_CTable litlengthCTable[FSE_CTABLE_SIZE_U32(LLFSELog, MaxLL)];
	FSE_repeat offcode_repeatMode;
	FSE_repeat matchlength_repeatMode;
	FSE_repeat litlength_repeatMode;
	} ZSTD_fseCTables_t;

	typedef struct {
	ZSTD_hufCTables_t huf;
	ZSTD_fseCTables_t fse;
	} ZSTD_entropyCTables_t;

	typedef struct {
	U32 off;
	U32 len;
	} ZSTD_match_t;

	typedef struct {
	int price;
	U32 off;
	U32 mlen;
	U32 litlen;
	U32 rep[ZSTD_REP_NUM];
	} ZSTD_optimal_t;

	typedef enum { zop_dynamic=0, zop_predef } ZSTD_OptPrice_e;

	typedef struct {
	/* All tables are allocated inside cctx->workspace by ZSTD_resetCCtx_internal() */
	unsigned* litFreq; /* table of literals statistics, of size 256 */
	unsigned* litLengthFreq; /* table of litLength statistics, of size (MaxLL+1) */
	unsigned* matchLengthFreq; /* table of matchLength statistics, of size (MaxML+1) */
	unsigned* offCodeFreq; /* table of offCode statistics, of size (MaxOff+1) */
	ZSTD_match_t* matchTable; /* list of found matches, of size ZSTD_OPT_NUM+1 */
	ZSTD_optimal_t* priceTable; /* All positions tracked by optimal parser, of size ZSTD_OPT_NUM+1 */

	U32 litSum; /* nb of literals */
	U32 litLengthSum; /* nb of litLength codes */
	U32 matchLengthSum; /* nb of matchLength codes */
	U32 offCodeSum; /* nb of offset codes */
	U32 litSumBasePrice; /* to compare to log2(litfreq) */
	U32 litLengthSumBasePrice; /* to compare to log2(llfreq) */
	U32 matchLengthSumBasePrice;/* to compare to log2(mlfreq) */
	U32 offCodeSumBasePrice; /* to compare to log2(offreq) */
	ZSTD_OptPrice_e priceType; /* prices can be determined dynamically, or follow a pre-defined cost structure */
	const ZSTD_entropyCTables_t* symbolCosts; /* pre-calculated dictionary statistics */
	ZSTD_literalCompressionMode_e literalCompressionMode;
	} optState_t;

	typedef struct {
	ZSTD_entropyCTables_t entropy;
	U32 rep[ZSTD_REP_NUM];
	} ZSTD_compressedBlockState_t;

	typedef struct {
	BYTE const* nextSrc; /* next block here to continue on current prefix */
	BYTE const* base; /* All regular indexes relative to this position */
	BYTE const* dictBase; /* extDict indexes relative to this position */
	U32 dictLimit; /* below that point, need extDict */
	U32 lowLimit; /* below that point, no more valid data */
	} ZSTD_window_t;

	typedef struct ZSTD_matchState_t ZSTD_matchState_t;
	struct ZSTD_matchState_t {
	ZSTD_window_t window; /* State for window round buffer management */
	U32 loadedDictEnd; /* index of end of dictionary, within context's referential.
	* When loadedDictEnd != 0, a dictionary is in use, and still valid.
	* This relies on a mechanism to set loadedDictEnd=0 when dictionary is no longer within distance.
	* Such mechanism is provided within ZSTD_window_enforceMaxDist() and ZSTD_checkDictValidity().
	* When dict referential is copied into active context (i.e. not attached),
	* loadedDictEnd == dictSize, since referential starts from zero.
	*/
	U32 nextToUpdate; /* index from which to continue table update */
	U32 hashLog3; /* dispatch table for matches of len==3 : larger == faster, more memory */
	U32* hashTable;
	U32* hashTable3;
	U32* chainTable;
	optState_t opt; /* optimal parser state */
	const ZSTD_matchState_t* dictMatchState;
	ZSTD_compressionParameters cParams;
	};

	typedef struct {
	ZSTD_compressedBlockState_t* prevCBlock;
	ZSTD_compressedBlockState_t* nextCBlock;
	ZSTD_matchState_t matchState;
	} ZSTD_blockState_t;

	typedef struct {
	U32 offset;
	U32 checksum;
	} ldmEntry_t;

	typedef struct {
	ZSTD_window_t window; /* State for the window round buffer management */
	ldmEntry_t* hashTable;
	U32 loadedDictEnd;
	BYTE* bucketOffsets; /* Next position in bucket to insert entry */
	U64 hashPower; /* Used to compute the rolling hash.
	* Depends on ldmParams.minMatchLength */
	} ldmState_t;

	typedef struct {
	U32 enableLdm; /* 1 if enable long distance matching */
	U32 hashLog; /* Log size of hashTable */
	U32 bucketSizeLog; /* Log bucket size for collision resolution, at most 8 */
	U32 minMatchLength; /* Minimum match length */
	U32 hashRateLog; /* Log number of entries to skip */
	U32 windowLog; /* Window log for the LDM */
	} ldmParams_t;

	typedef struct {
	U32 offset;
	U32 litLength;
	U32 matchLength;
	} rawSeq;

	typedef struct {
	rawSeq* seq; /* The start of the sequences */
	size_t pos; /* The position where reading stopped. <= size. */
	size_t size; /* The number of sequences. <= capacity. */
	size_t capacity; /* The capacity starting from `seq` pointer */
	} rawSeqStore_t;

	typedef struct {
	int collectSequences;
	ZSTD_Sequence* seqStart;
	size_t seqIndex;
	size_t maxSequences;
	} SeqCollector;

	struct ZSTD_CCtx_params_s {
	ZSTD_format_e format;
	ZSTD_compressionParameters cParams;
	ZSTD_frameParameters fParams;

	int compressionLevel;
	int forceWindow; /* force back-references to respect limit of
	* 1<<wLog, even for dictionary */
	size_t targetCBlockSize; /* Tries to fit compressed block size to be around targetCBlockSize.
	* No target when targetCBlockSize == 0.
	* There is no guarantee on compressed block size */
	int srcSizeHint; /* User's best guess of source size.
	* Hint is not valid when srcSizeHint == 0.
	* There is no guarantee that hint is close to actual source size */

	ZSTD_dictAttachPref_e attachDictPref;
	ZSTD_literalCompressionMode_e literalCompressionMode;

	/* Multithreading: used to pass parameters to mtctx */
	int nbWorkers;
	size_t jobSize;
	int overlapLog;
	int rsyncable;

	/* Long distance matching parameters */
	ldmParams_t ldmParams;

	/* Internal use, for createCCtxParams() and freeCCtxParams() only */
	ZSTD_customMem customMem;
	}; /* typedef'd to ZSTD_CCtx_params within "zstd.h" */

	struct ZSTD_CCtx_s {
	ZSTD_compressionStage_e stage;
	int cParamsChanged; /* == 1 if cParams(except wlog) or compression level are changed in requestedParams. Triggers transmission of new params to ZSTDMT (if available) then reset to 0. */
	int bmi2; /* == 1 if the CPU supports BMI2 and 0 otherwise. CPU support is determined dynamically once per context lifetime. */
	ZSTD_CCtx_params requestedParams;
	ZSTD_CCtx_params appliedParams;
	U32 dictID;

	ZSTD_cwksp workspace; /* manages buffer for dynamic allocations */
	size_t blockSize;
	unsigned long long pledgedSrcSizePlusOne; /* this way, 0 (default) == unknown */
	unsigned long long consumedSrcSize;
	unsigned long long producedCSize;
	XXH64_state_t xxhState;
	ZSTD_customMem customMem;
	size_t staticSize;
	SeqCollector seqCollector;
	int isFirstBlock;
	int initialized;

	seqStore_t seqStore; /* sequences storage ptrs */
	ldmState_t ldmState; /* long distance matching state */
	rawSeq* ldmSequences; /* Storage for the ldm output sequences */
	size_t maxNbLdmSequences;
	rawSeqStore_t externSeqStore; /* Mutable reference to external sequences */
	ZSTD_blockState_t blockState;
	U32* entropyWorkspace; /* entropy workspace of HUF_WORKSPACE_SIZE bytes */

	/* streaming */
	char* inBuff;
	size_t inBuffSize;
	size_t inToCompress;
	size_t inBuffPos;
	size_t inBuffTarget;
	char* outBuff;
	size_t outBuffSize;
	size_t outBuffContentSize;
	size_t outBuffFlushedSize;
	ZSTD_cStreamStage streamStage;
	U32 frameEnded;

	/* Dictionary */
	ZSTD_localDict localDict;
	const ZSTD_CDict* cdict;
	ZSTD_prefixDict prefixDict; /* single-usage dictionary */

	/* Multi-threading */
	#ifdef ZSTD_MULTITHREAD
	ZSTDMT_CCtx* mtctx;
	#endif
	};

	typedef enum { ZSTD_dtlm_fast, ZSTD_dtlm_full } ZSTD_dictTableLoadMethod_e;

	typedef enum { ZSTD_noDict = 0, ZSTD_extDict = 1, ZSTD_dictMatchState = 2 } ZSTD_dictMode_e;


	typedef size_t (*ZSTD_blockCompressor) (
	ZSTD_matchState_t* bs, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
	void const* src, size_t srcSize);
	ZSTD_blockCompressor ZSTD_selectBlockCompressor(ZSTD_strategy strat, ZSTD_dictMode_e dictMode);


	MEM_STATIC U32 ZSTD_LLcode(U32 litLength)
	{
	static const BYTE LL_Code[64] = { 0, 1, 2, 3, 4, 5, 6, 7,
	8, 9, 10, 11, 12, 13, 14, 15,
	16, 16, 17, 17, 18, 18, 19, 19,
	20, 20, 20, 20, 21, 21, 21, 21,
	22, 22, 22, 22, 22, 22, 22, 22,
	23, 23, 23, 23, 23, 23, 23, 23,
	24, 24, 24, 24, 24, 24, 24, 24,
	24, 24, 24, 24, 24, 24, 24, 24 };
	static const U32 LL_deltaCode = 19;
	return (litLength > 63) ? ZSTD_highbit32(litLength) + LL_deltaCode : LL_Code[litLength];
	}

	/* ZSTD_MLcode() :
	* note : mlBase = matchLength - MINMATCH;
	* because it's the format it's stored in seqStore->sequences */
	MEM_STATIC U32 ZSTD_MLcode(U32 mlBase)
	{
	static const BYTE ML_Code[128] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
	16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
	32, 32, 33, 33, 34, 34, 35, 35, 36, 36, 36, 36, 37, 37, 37, 37,
	38, 38, 38, 38, 38, 38, 38, 38, 39, 39, 39, 39, 39, 39, 39, 39,
	40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
	41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
	42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
	42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42 };
	static const U32 ML_deltaCode = 36;
	return (mlBase > 127) ? ZSTD_highbit32(mlBase) + ML_deltaCode : ML_Code[mlBase];
	}

	typedef struct repcodes_s {
	U32 rep[3];
	} repcodes_t;

	MEM_STATIC repcodes_t ZSTD_updateRep(U32 const rep[3], U32 const offset, U32 const ll0)
	{
	repcodes_t newReps;
	if (offset >= ZSTD_REP_NUM) { /* full offset */
	newReps.rep[2] = rep[1];
	newReps.rep[1] = rep[0];
	newReps.rep[0] = offset - ZSTD_REP_MOVE;
	} else { /* repcode */
	U32 const repCode = offset + ll0;
	if (repCode > 0) { /* note : if repCode==0, no change */
	U32 const currentOffset = (repCode==ZSTD_REP_NUM) ? (rep[0] - 1) : rep[repCode];
	newReps.rep[2] = (repCode >= 2) ? rep[1] : rep[2];
	newReps.rep[1] = rep[0];
	newReps.rep[0] = currentOffset;
	} else { /* repCode == 0 */
	memcpy(&newReps, rep, sizeof(newReps));
	}
	}
	return newReps;
	}

	/* ZSTD_cParam_withinBounds:
	* @return 1 if value is within cParam bounds,
	* 0 otherwise */
	MEM_STATIC int ZSTD_cParam_withinBounds(ZSTD_cParameter cParam, int value)
	{
	ZSTD_bounds const bounds = ZSTD_cParam_getBounds(cParam);
	if (ZSTD_isError(bounds.error)) return 0;
	if (value < bounds.lowerBound) return 0;
	if (value > bounds.upperBound) return 0;
	return 1;
	}

	/* ZSTD_noCompressBlock() :
	* Writes uncompressed block to dst buffer from given src.
	* Returns the size of the block */
	MEM_STATIC size_t ZSTD_noCompressBlock (void* dst, size_t dstCapacity, const void* src, size_t srcSize, U32 lastBlock)
	{
	U32 const cBlockHeader24 = lastBlock + (((U32)bt_raw)<<1) + (U32)(srcSize << 3);
	RETURN_ERROR_IF(srcSize + ZSTD_blockHeaderSize > dstCapacity,
	dstSize_tooSmall, "dst buf too small for uncompressed block");
	MEM_writeLE24(dst, cBlockHeader24);
	memcpy((BYTE*)dst + ZSTD_blockHeaderSize, src, srcSize);
	return ZSTD_blockHeaderSize + srcSize;
	}

	MEM_STATIC size_t ZSTD_rleCompressBlock (void* dst, size_t dstCapacity, BYTE src, size_t srcSize, U32 lastBlock)
	{
	BYTE* const op = (BYTE*)dst;
	U32 const cBlockHeader = lastBlock + (((U32)bt_rle)<<1) + (U32)(srcSize << 3);
	RETURN_ERROR_IF(dstCapacity < 4, dstSize_tooSmall, "");
	MEM_writeLE24(op, cBlockHeader);
	op[3] = src;
	return 4;
	}


	/* ZSTD_minGain() :
	* minimum compression required
	* to generate a compress block or a compressed literals section.
	* note : use same formula for both situations */
	MEM_STATIC size_t ZSTD_minGain(size_t srcSize, ZSTD_strategy strat)
	{
	U32 const minlog = (strat>=ZSTD_btultra) ? (U32)(strat) - 1 : 6;
	ZSTD_STATIC_ASSERT(ZSTD_btultra == 8);
	assert(ZSTD_cParam_withinBounds(ZSTD_c_strategy, strat));
	return (srcSize >> minlog) + 2;
	}

	MEM_STATIC int ZSTD_disableLiteralsCompression(const ZSTD_CCtx_params* cctxParams)
	{
	switch (cctxParams->literalCompressionMode) {
	case ZSTD_lcm_huffman:
	return 0;
	case ZSTD_lcm_uncompressed:
	return 1;
	default:
	assert(0 /* impossible: pre-validated */);
	/* fall-through */
	case ZSTD_lcm_auto:
	return (cctxParams->cParams.strategy == ZSTD_fast) && (cctxParams->cParams.targetLength > 0);
	}
	}

	/*! ZSTD_safecopyLiterals() :
	* memcpy() function that won't read beyond more than WILDCOPY_OVERLENGTH bytes past ilimit_w.
	* Only called when the sequence ends past ilimit_w, so it only needs to be optimized for single
	* large copies.
	*/
	static void ZSTD_safecopyLiterals(BYTE* op, BYTE const* ip, BYTE const* const iend, BYTE const* ilimit_w) {
	assert(iend > ilimit_w);
	if (ip <= ilimit_w) {
	ZSTD_wildcopy(op, ip, ilimit_w - ip, ZSTD_no_overlap);
	op += ilimit_w - ip;
	ip = ilimit_w;
	}
	while (ip < iend) op++ = ip++;
	}

	/*! ZSTD_storeSeq() :
	* Store a sequence (litlen, litPtr, offCode and mlBase) into seqStore_t.
	* `offCode` : distance to match + ZSTD_REP_MOVE (values <= ZSTD_REP_MOVE are repCodes).
	* `mlBase` : matchLength - MINMATCH
	* Allowed to overread literals up to litLimit.
	*/
	HINT_INLINE UNUSED_ATTR
	void ZSTD_storeSeq(seqStore_t* seqStorePtr, size_t litLength, const BYTE* literals, const BYTE* litLimit, U32 offCode, size_t mlBase)
	{
	BYTE const* const litLimit_w = litLimit - WILDCOPY_OVERLENGTH;
	BYTE const* const litEnd = literals + litLength;
	#if defined(DEBUGLEVEL) && (DEBUGLEVEL >= 6)
	static const BYTE* g_start = NULL;
	if (g_start==NULL) g_start = (const BYTE)literals; / note : index only works for compression within a single segment */
	{ U32 const pos = (U32)((const BYTE*)literals - g_start);
	DEBUGLOG(6, "Cpos%7u :%3u literals, match%4u bytes at offCode%7u",
	pos, (U32)litLength, (U32)mlBase+MINMATCH, (U32)offCode);
	}
	#endif
	assert((size_t)(seqStorePtr->sequences - seqStorePtr->sequencesStart) < seqStorePtr->maxNbSeq);
	/* copy Literals */
	assert(seqStorePtr->maxNbLit <= 128 KB);
	assert(seqStorePtr->lit + litLength <= seqStorePtr->litStart + seqStorePtr->maxNbLit);
	assert(literals + litLength <= litLimit);
	if (litEnd <= litLimit_w) {
	/* Common case we can use wildcopy.
	* First copy 16 bytes, because literals are likely short.
	*/
	assert(WILDCOPY_OVERLENGTH >= 16);
	ZSTD_copy16(seqStorePtr->lit, literals);
	if (litLength > 16) {
	ZSTD_wildcopy(seqStorePtr->lit+16, literals+16, (ptrdiff_t)litLength-16, ZSTD_no_overlap);
	}
	} else {
	ZSTD_safecopyLiterals(seqStorePtr->lit, literals, litEnd, litLimit_w);
	}
	seqStorePtr->lit += litLength;

	/* literal Length */
	if (litLength>0xFFFF) {
	assert(seqStorePtr->longLengthID == 0); /* there can only be a single long length */
	seqStorePtr->longLengthID = 1;
	seqStorePtr->longLengthPos = (U32)(seqStorePtr->sequences - seqStorePtr->sequencesStart);
	}
	seqStorePtr->sequences[0].litLength = (U16)litLength;

	/* match offset */
	seqStorePtr->sequences[0].offset = offCode + 1;

	/* match Length */
	if (mlBase>0xFFFF) {
	assert(seqStorePtr->longLengthID == 0); /* there can only be a single long length */
	seqStorePtr->longLengthID = 2;
	seqStorePtr->longLengthPos = (U32)(seqStorePtr->sequences - seqStorePtr->sequencesStart);
	}
	seqStorePtr->sequences[0].matchLength = (U16)mlBase;

	seqStorePtr->sequences++;
	}


	/-************************************
	* Match length counter
	***************************************/
	static unsigned ZSTD_NbCommonBytes (size_t val)
	{
	if (MEM_isLittleEndian()) {
	if (MEM_64bits()) {
	# if defined(_MSC_VER) && defined(_WIN64)
	unsigned long r = 0;
	return _BitScanForward64( &r, (U64)val ) ? (unsigned)(r >> 3) : 0;
	# elif defined(__GNUC__) && (__GNUC__ >= 4)
	return (__builtin_ctzll((U64)val) >> 3);
	# else
	static const int DeBruijnBytePos[64] = { 0, 0, 0, 0, 0, 1, 1, 2,
	0, 3, 1, 3, 1, 4, 2, 7,
	0, 2, 3, 6, 1, 5, 3, 5,
	1, 3, 4, 4, 2, 5, 6, 7,
	7, 0, 1, 2, 3, 3, 4, 6,
	2, 6, 5, 5, 3, 4, 5, 6,
	7, 1, 2, 4, 6, 4, 4, 5,
	7, 2, 6, 5, 7, 6, 7, 7 };
	return DeBruijnBytePos[((U64)((val & -(long long)val) * 0x0218A392CDABBD3FULL)) >> 58];
	# endif
	} else { /* 32 bits */
	# if defined(_MSC_VER)
	unsigned long r=0;
	return _BitScanForward( &r, (U32)val ) ? (unsigned)(r >> 3) : 0;
	# elif defined(__GNUC__) && (__GNUC__ >= 3)
	return (__builtin_ctz((U32)val) >> 3);
	# else
	static const int DeBruijnBytePos[32] = { 0, 0, 3, 0, 3, 1, 3, 0,
	3, 2, 2, 1, 3, 2, 0, 1,
	3, 3, 1, 2, 2, 2, 2, 0,
	3, 1, 2, 0, 1, 0, 1, 1 };
	return DeBruijnBytePos[((U32)((val & -(S32)val) * 0x077CB531U)) >> 27];
	# endif
	}
	} else { /* Big Endian CPU */
	if (MEM_64bits()) {
	# if defined(_MSC_VER) && defined(_WIN64)
	unsigned long r = 0;
	return _BitScanReverse64( &r, val ) ? (unsigned)(r >> 3) : 0;
	# elif defined(__GNUC__) && (__GNUC__ >= 4)
	return (__builtin_clzll(val) >> 3);
	# else
	unsigned r;
	const unsigned n32 = sizeof(size_t)4; / calculate this way due to compiler complaining in 32-bits mode */
	if (!(val>>n32)) { r=4; } else { r=0; val>>=n32; }
	if (!(val>>16)) { r+=2; val>>=8; } else { val>>=24; }
	r += (!val);
	return r;
	# endif
	} else { /* 32 bits */
	# if defined(_MSC_VER)
	unsigned long r = 0;
	return _BitScanReverse( &r, (unsigned long)val ) ? (unsigned)(r >> 3) : 0;
	# elif defined(__GNUC__) && (__GNUC__ >= 3)
	return (__builtin_clz((U32)val) >> 3);
	# else
	unsigned r;
	if (!(val>>16)) { r=2; val>>=8; } else { r=0; val>>=24; }
	r += (!val);
	return r;
	# endif
	} }
	}


	MEM_STATIC size_t ZSTD_count(const BYTE* pIn, const BYTE* pMatch, const BYTE* const pInLimit)
	{
	const BYTE* const pStart = pIn;
	const BYTE* const pInLoopLimit = pInLimit - (sizeof(size_t)-1);

	if (pIn < pInLoopLimit) {
	{ size_t const diff = MEM_readST(pMatch) ^ MEM_readST(pIn);
	if (diff) return ZSTD_NbCommonBytes(diff); }
	pIn+=sizeof(size_t); pMatch+=sizeof(size_t);
	while (pIn < pInLoopLimit) {
	size_t const diff = MEM_readST(pMatch) ^ MEM_readST(pIn);
	if (!diff) { pIn+=sizeof(size_t); pMatch+=sizeof(size_t); continue; }
	pIn += ZSTD_NbCommonBytes(diff);
	return (size_t)(pIn - pStart);
	} }
	if (MEM_64bits() && (pIn<(pInLimit-3)) && (MEM_read32(pMatch) == MEM_read32(pIn))) { pIn+=4; pMatch+=4; }
	if ((pIn<(pInLimit-1)) && (MEM_read16(pMatch) == MEM_read16(pIn))) { pIn+=2; pMatch+=2; }
	if ((pIn<pInLimit) && (pMatch == pIn)) pIn++;
	return (size_t)(pIn - pStart);
	}

	/** ZSTD_count_2segments() :
	* can count match length with `ip` & `match` in 2 different segments.
	* convention : on reaching mEnd, match count continue starting from iStart
	*/
	MEM_STATIC size_t
	ZSTD_count_2segments(const BYTE* ip, const BYTE* match,
	const BYTE* iEnd, const BYTE* mEnd, const BYTE* iStart)
	{
	const BYTE* const vEnd = MIN( ip + (mEnd - match), iEnd);
	size_t const matchLength = ZSTD_count(ip, match, vEnd);
	if (match + matchLength != mEnd) return matchLength;
	DEBUGLOG(7, "ZSTD_count_2segments: found a 2-parts match (current length==%zu)", matchLength);
	DEBUGLOG(7, "distance from match beginning to end dictionary = %zi", mEnd - match);
	DEBUGLOG(7, "distance from current pos to end buffer = %zi", iEnd - ip);
	DEBUGLOG(7, "next byte : ip==%02X, istart==%02X", ip[matchLength], *iStart);
	DEBUGLOG(7, "final match length = %zu", matchLength + ZSTD_count(ip+matchLength, iStart, iEnd));
	return matchLength + ZSTD_count(ip+matchLength, iStart, iEnd);
	}


	/-************************************
	* Hashes
	***************************************/
	static const U32 prime3bytes = 506832829U;
	static U32 ZSTD_hash3(U32 u, U32 h) { return ((u << (32-24)) * prime3bytes) >> (32-h) ; }
	MEM_STATIC size_t ZSTD_hash3Ptr(const void* ptr, U32 h) { return ZSTD_hash3(MEM_readLE32(ptr), h); } /* only in zstd_opt.h */

	static const U32 prime4bytes = 2654435761U;
	static U32 ZSTD_hash4(U32 u, U32 h) { return (u * prime4bytes) >> (32-h) ; }
	static size_t ZSTD_hash4Ptr(const void* ptr, U32 h) { return ZSTD_hash4(MEM_read32(ptr), h); }

	static const U64 prime5bytes = 889523592379ULL;
	static size_t ZSTD_hash5(U64 u, U32 h) { return (size_t)(((u << (64-40)) * prime5bytes) >> (64-h)) ; }
	static size_t ZSTD_hash5Ptr(const void* p, U32 h) { return ZSTD_hash5(MEM_readLE64(p), h); }

	static const U64 prime6bytes = 227718039650203ULL;
	static size_t ZSTD_hash6(U64 u, U32 h) { return (size_t)(((u << (64-48)) * prime6bytes) >> (64-h)) ; }
	static size_t ZSTD_hash6Ptr(const void* p, U32 h) { return ZSTD_hash6(MEM_readLE64(p), h); }

	static const U64 prime7bytes = 58295818150454627ULL;
	static size_t ZSTD_hash7(U64 u, U32 h) { return (size_t)(((u << (64-56)) * prime7bytes) >> (64-h)) ; }
	static size_t ZSTD_hash7Ptr(const void* p, U32 h) { return ZSTD_hash7(MEM_readLE64(p), h); }

	static const U64 prime8bytes = 0xCF1BBCDCB7A56463ULL;
	static size_t ZSTD_hash8(U64 u, U32 h) { return (size_t)(((u) * prime8bytes) >> (64-h)) ; }
	static size_t ZSTD_hash8Ptr(const void* p, U32 h) { return ZSTD_hash8(MEM_readLE64(p), h); }

	MEM_STATIC size_t ZSTD_hashPtr(const void* p, U32 hBits, U32 mls)
	{
	switch(mls)
	{
	default:
	case 4: return ZSTD_hash4Ptr(p, hBits);
	case 5: return ZSTD_hash5Ptr(p, hBits);
	case 6: return ZSTD_hash6Ptr(p, hBits);
	case 7: return ZSTD_hash7Ptr(p, hBits);
	case 8: return ZSTD_hash8Ptr(p, hBits);
	}
	}

	/** ZSTD_ipow() :
	* Return base^exponent.
	*/
	static U64 ZSTD_ipow(U64 base, U64 exponent)
	{
	U64 power = 1;
	while (exponent) {
	if (exponent & 1) power *= base;
	exponent >>= 1;
	base *= base;
	}
	return power;
	}

	#define ZSTD_ROLL_HASH_CHAR_OFFSET 10

	/** ZSTD_rollingHash_append() :
	* Add the buffer to the hash value.
	*/
	static U64 ZSTD_rollingHash_append(U64 hash, void const* buf, size_t size)
	{
	BYTE const* istart = (BYTE const*)buf;
	size_t pos;
	for (pos = 0; pos < size; ++pos) {
	hash *= prime8bytes;
	hash += istart[pos] + ZSTD_ROLL_HASH_CHAR_OFFSET;
	}
	return hash;
	}

	/** ZSTD_rollingHash_compute() :
	* Compute the rolling hash value of the buffer.
	*/
	MEM_STATIC U64 ZSTD_rollingHash_compute(void const* buf, size_t size)
	{
	return ZSTD_rollingHash_append(0, buf, size);
	}

	/** ZSTD_rollingHash_primePower() :
	* Compute the primePower to be passed to ZSTD_rollingHash_rotate() for a hash
	* over a window of length bytes.
	*/
	MEM_STATIC U64 ZSTD_rollingHash_primePower(U32 length)
	{
	return ZSTD_ipow(prime8bytes, length - 1);
	}

	/** ZSTD_rollingHash_rotate() :
	* Rotate the rolling hash by one byte.
	*/
	MEM_STATIC U64 ZSTD_rollingHash_rotate(U64 hash, BYTE toRemove, BYTE toAdd, U64 primePower)
	{
	hash -= (toRemove + ZSTD_ROLL_HASH_CHAR_OFFSET) * primePower;
	hash *= prime8bytes;
	hash += toAdd + ZSTD_ROLL_HASH_CHAR_OFFSET;
	return hash;
	}

	/-************************************
	* Round buffer management
	***************************************/
	#if (ZSTD_WINDOWLOG_MAX_64 > 31)
	# error "ZSTD_WINDOWLOG_MAX is too large : would overflow ZSTD_CURRENT_MAX"
	#endif
	/* Max current allowed */
	#define ZSTD_CURRENT_MAX ((3U << 29) + (1U << ZSTD_WINDOWLOG_MAX))
	/* Maximum chunk size before overflow correction needs to be called again */
	#define ZSTD_CHUNKSIZE_MAX \
	( ((U32)-1) /* Maximum ending current index */ \
	- ZSTD_CURRENT_MAX) /* Maximum beginning lowLimit */

	/**
	* ZSTD_window_clear():
	* Clears the window containing the history by simply setting it to empty.
	*/
	MEM_STATIC void ZSTD_window_clear(ZSTD_window_t* window)
	{
	size_t const endT = (size_t)(window->nextSrc - window->base);
	U32 const end = (U32)endT;

	window->lowLimit = end;
	window->dictLimit = end;
	}

	/**
	* ZSTD_window_hasExtDict():
	* Returns non-zero if the window has a non-empty extDict.
	*/
	MEM_STATIC U32 ZSTD_window_hasExtDict(ZSTD_window_t const window)
	{
	return window.lowLimit < window.dictLimit;
	}

	/**
	* ZSTD_matchState_dictMode():
	* Inspects the provided matchState and figures out what dictMode should be
	* passed to the compressor.
	*/
	MEM_STATIC ZSTD_dictMode_e ZSTD_matchState_dictMode(const ZSTD_matchState_t *ms)
	{
	return ZSTD_window_hasExtDict(ms->window) ?
	ZSTD_extDict :
	ms->dictMatchState != NULL ?
	ZSTD_dictMatchState :
	ZSTD_noDict;
	}

	/**
	* ZSTD_window_needOverflowCorrection():
	* Returns non-zero if the indices are getting too large and need overflow
	* protection.
	*/
	MEM_STATIC U32 ZSTD_window_needOverflowCorrection(ZSTD_window_t const window,
	void const* srcEnd)
	{
	U32 const current = (U32)((BYTE const*)srcEnd - window.base);
	return current > ZSTD_CURRENT_MAX;
	}

	/**
	* ZSTD_window_correctOverflow():
	* Reduces the indices to protect from index overflow.
	* Returns the correction made to the indices, which must be applied to every
	* stored index.
	*
	* The least significant cycleLog bits of the indices must remain the same,
	* which may be 0. Every index up to maxDist in the past must be valid.
	* NOTE: (maxDist & cycleMask) must be zero.
	*/
	MEM_STATIC U32 ZSTD_window_correctOverflow(ZSTD_window_t* window, U32 cycleLog,
	U32 maxDist, void const* src)
	{
	/* preemptive overflow correction:
	* 1. correction is large enough:
	* lowLimit > (3<<29) ==> current > 3<<29 + 1<<windowLog
	* 1<<windowLog <= newCurrent < 1<<chainLog + 1<<windowLog
	*
	* current - newCurrent
	* > (3<<29 + 1<<windowLog) - (1<<windowLog + 1<<chainLog)
	* > (3<<29) - (1<<chainLog)
	* > (3<<29) - (1<<30) (NOTE: chainLog <= 30)
	* > 1<<29
	*
	* 2. (ip+ZSTD_CHUNKSIZE_MAX - cctx->base) doesn't overflow:
	* After correction, current is less than (1<<chainLog + 1<<windowLog).
	* In 64-bit mode we are safe, because we have 64-bit ptrdiff_t.
	* In 32-bit mode we are safe, because (chainLog <= 29), so
	* ip+ZSTD_CHUNKSIZE_MAX - cctx->base < 1<<32.
	* 3. (cctx->lowLimit + 1<<windowLog) < 1<<32:
	* windowLog <= 31 ==> 3<<29 + 1<<windowLog < 7<<29 < 1<<32.
	*/
	U32 const cycleMask = (1U << cycleLog) - 1;
	U32 const current = (U32)((BYTE const*)src - window->base);
	U32 const currentCycle0 = current & cycleMask;
	/* Exclude zero so that newCurrent - maxDist >= 1. */
	U32 const currentCycle1 = currentCycle0 == 0 ? (1U << cycleLog) : currentCycle0;
	U32 const newCurrent = currentCycle1 + maxDist;
	U32 const correction = current - newCurrent;
	assert((maxDist & cycleMask) == 0);
	assert(current > newCurrent);
	/* Loose bound, should be around 1<<29 (see above) */
	assert(correction > 1<<28);

	window->base += correction;
	window->dictBase += correction;
	if (window->lowLimit <= correction) window->lowLimit = 1;
	else window->lowLimit -= correction;
	if (window->dictLimit <= correction) window->dictLimit = 1;
	else window->dictLimit -= correction;

	/* Ensure we can still reference the full window. */
	assert(newCurrent >= maxDist);
	assert(newCurrent - maxDist >= 1);
	/* Ensure that lowLimit and dictLimit didn't underflow. */
	assert(window->lowLimit <= newCurrent);
	assert(window->dictLimit <= newCurrent);

	DEBUGLOG(4, "Correction of 0x%x bytes to lowLimit=0x%x", correction,
	window->lowLimit);
	return correction;
	}

	/**
	* ZSTD_window_enforceMaxDist():
	* Updates lowLimit so that:
	* (srcEnd - base) - lowLimit == maxDist + loadedDictEnd
	*
	* It ensures index is valid as long as index >= lowLimit.
	* This must be called before a block compression call.
	*
	* loadedDictEnd is only defined if a dictionary is in use for current compression.
	* As the name implies, loadedDictEnd represents the index at end of dictionary.
	* The value lies within context's referential, it can be directly compared to blockEndIdx.
	*
	* If loadedDictEndPtr is NULL, no dictionary is in use, and we use loadedDictEnd == 0.
	* If loadedDictEndPtr is not NULL, we set it to zero after updating lowLimit.
	* This is because dictionaries are allowed to be referenced fully
	* as long as the last byte of the dictionary is in the window.
	* Once input has progressed beyond window size, dictionary cannot be referenced anymore.
	*
	* In normal dict mode, the dictionary lies between lowLimit and dictLimit.
	* In dictMatchState mode, lowLimit and dictLimit are the same,
	* and the dictionary is below them.
	* forceWindow and dictMatchState are therefore incompatible.
	*/
	MEM_STATIC void
	ZSTD_window_enforceMaxDist(ZSTD_window_t* window,
	const void* blockEnd,
	U32 maxDist,
	U32* loadedDictEndPtr,
	const ZSTD_matchState_t** dictMatchStatePtr)
	{
	U32 const blockEndIdx = (U32)((BYTE const*)blockEnd - window->base);
	U32 const loadedDictEnd = (loadedDictEndPtr != NULL) ? *loadedDictEndPtr : 0;
	DEBUGLOG(5, "ZSTD_window_enforceMaxDist: blockEndIdx=%u, maxDist=%u, loadedDictEnd=%u",
	(unsigned)blockEndIdx, (unsigned)maxDist, (unsigned)loadedDictEnd);

	/* - When there is no dictionary : loadedDictEnd == 0.
	In which case, the test (blockEndIdx > maxDist) is merely to avoid
	overflowing next operation `newLowLimit = blockEndIdx - maxDist`.
	- When there is a standard dictionary :
	Index referential is copied from the dictionary,
	which means it starts from 0.
	In which case, loadedDictEnd == dictSize,
	and it makes sense to compare `blockEndIdx > maxDist + dictSize`
	since `blockEndIdx` also starts from zero.
	- When there is an attached dictionary :
	loadedDictEnd is expressed within the referential of the context,
	so it can be directly compared against blockEndIdx.
	*/
	if (blockEndIdx > maxDist + loadedDictEnd) {
	U32 const newLowLimit = blockEndIdx - maxDist;
	if (window->lowLimit < newLowLimit) window->lowLimit = newLowLimit;
	if (window->dictLimit < window->lowLimit) {
	DEBUGLOG(5, "Update dictLimit to match lowLimit, from %u to %u",
	(unsigned)window->dictLimit, (unsigned)window->lowLimit);
	window->dictLimit = window->lowLimit;
	}
	/* On reaching window size, dictionaries are invalidated */
	if (loadedDictEndPtr) *loadedDictEndPtr = 0;
	if (dictMatchStatePtr) *dictMatchStatePtr = NULL;
	}
	}

	/* Similar to ZSTD_window_enforceMaxDist(),
	* but only invalidates dictionary
	* when input progresses beyond window size.
	* assumption : loadedDictEndPtr and dictMatchStatePtr are valid (non NULL)
	* loadedDictEnd uses same referential as window->base
	* maxDist is the window size */
	MEM_STATIC void
	ZSTD_checkDictValidity(const ZSTD_window_t* window,
	const void* blockEnd,
	U32 maxDist,
	U32* loadedDictEndPtr,
	const ZSTD_matchState_t** dictMatchStatePtr)
	{
	assert(loadedDictEndPtr != NULL);
	assert(dictMatchStatePtr != NULL);
	{ U32 const blockEndIdx = (U32)((BYTE const*)blockEnd - window->base);
	U32 const loadedDictEnd = *loadedDictEndPtr;
	DEBUGLOG(5, "ZSTD_checkDictValidity: blockEndIdx=%u, maxDist=%u, loadedDictEnd=%u",
	(unsigned)blockEndIdx, (unsigned)maxDist, (unsigned)loadedDictEnd);
	assert(blockEndIdx >= loadedDictEnd);

	if (blockEndIdx > loadedDictEnd + maxDist) {
	/* On reaching window size, dictionaries are invalidated.
	* For simplification, if window size is reached anywhere within next block,
	* the dictionary is invalidated for the full block.
	*/
	DEBUGLOG(6, "invalidating dictionary for current block (distance > windowSize)");
	*loadedDictEndPtr = 0;
	*dictMatchStatePtr = NULL;
	} else {
	if (*loadedDictEndPtr != 0) {
	DEBUGLOG(6, "dictionary considered valid for current block");
	} } }
	}

	MEM_STATIC void ZSTD_window_init(ZSTD_window_t* window) {
	memset(window, 0, sizeof(*window));
	window->base = (BYTE const*)"";
	window->dictBase = (BYTE const*)"";
	window->dictLimit = 1; /* start from 1, so that 1st position is valid */
	window->lowLimit = 1; /* it ensures first and later CCtx usages compress the same */
	window->nextSrc = window->base + 1; /* see issue #1241 */
	}

	/**
	* ZSTD_window_update():
	* Updates the window by appending [src, src + srcSize) to the window.
	* If it is not contiguous, the current prefix becomes the extDict, and we
	* forget about the extDict. Handles overlap of the prefix and extDict.
	* Returns non-zero if the segment is contiguous.
	*/
	MEM_STATIC U32 ZSTD_window_update(ZSTD_window_t* window,
	void const* src, size_t srcSize)
	{
	BYTE const* const ip = (BYTE const*)src;
	U32 contiguous = 1;
	DEBUGLOG(5, "ZSTD_window_update");
	if (srcSize == 0)
	return contiguous;
	assert(window->base != NULL);
	assert(window->dictBase != NULL);
	/* Check if blocks follow each other */
	if (src != window->nextSrc) {
	/* not contiguous */
	size_t const distanceFromBase = (size_t)(window->nextSrc - window->base);
	DEBUGLOG(5, "Non contiguous blocks, new segment starts at %u", window->dictLimit);
	window->lowLimit = window->dictLimit;
	assert(distanceFromBase == (size_t)(U32)distanceFromBase); /* should never overflow */
	window->dictLimit = (U32)distanceFromBase;
	window->dictBase = window->base;
	window->base = ip - distanceFromBase;
	/* ms->nextToUpdate = window->dictLimit; */
	if (window->dictLimit - window->lowLimit < HASH_READ_SIZE) window->lowLimit = window->dictLimit; /* too small extDict */
	contiguous = 0;
	}
	window->nextSrc = ip + srcSize;
	/* if input and dictionary overlap : reduce dictionary (area presumed modified by input) */
	if ( (ip+srcSize > window->dictBase + window->lowLimit)
	& (ip < window->dictBase + window->dictLimit)) {
	ptrdiff_t const highInputIdx = (ip + srcSize) - window->dictBase;
	U32 const lowLimitMax = (highInputIdx > (ptrdiff_t)window->dictLimit) ? window->dictLimit : (U32)highInputIdx;
	window->lowLimit = lowLimitMax;
	DEBUGLOG(5, "Overlapping extDict and input : new lowLimit = %u", window->lowLimit);
	}
	return contiguous;
	}

	/**
	* Returns the lowest allowed match index. It may either be in the ext-dict or the prefix.
	*/
	MEM_STATIC U32 ZSTD_getLowestMatchIndex(const ZSTD_matchState_t* ms, U32 current, unsigned windowLog)
	{
	U32 const maxDistance = 1U << windowLog;
	U32 const lowestValid = ms->window.lowLimit;
	U32 const withinWindow = (current - lowestValid > maxDistance) ? current - maxDistance : lowestValid;
	U32 const isDictionary = (ms->loadedDictEnd != 0);
	U32 const matchLowest = isDictionary ? lowestValid : withinWindow;
	return matchLowest;
	}

	/**
	* Returns the lowest allowed match index in the prefix.
	*/
	MEM_STATIC U32 ZSTD_getLowestPrefixIndex(const ZSTD_matchState_t* ms, U32 current, unsigned windowLog)
	{
	U32 const maxDistance = 1U << windowLog;
	U32 const lowestValid = ms->window.dictLimit;
	U32 const withinWindow = (current - lowestValid > maxDistance) ? current - maxDistance : lowestValid;
	U32 const isDictionary = (ms->loadedDictEnd != 0);
	U32 const matchLowest = isDictionary ? lowestValid : withinWindow;
	return matchLowest;
	}



	/* debug functions */
	#if (DEBUGLEVEL>=2)

	MEM_STATIC double ZSTD_fWeight(U32 rawStat)
	{
	U32 const fp_accuracy = 8;
	U32 const fp_multiplier = (1 << fp_accuracy);
	U32 const newStat = rawStat + 1;
	U32 const hb = ZSTD_highbit32(newStat);
	U32 const BWeight = hb * fp_multiplier;
	U32 const FWeight = (newStat << fp_accuracy) >> hb;
	U32 const weight = BWeight + FWeight;
	assert(hb + fp_accuracy < 31);
	return (double)weight / fp_multiplier;
	}

	/* display a table content,
	* listing each element, its frequency, and its predicted bit cost */
	MEM_STATIC void ZSTD_debugTable(const U32* table, U32 max)
	{
	unsigned u, sum;
	for (u=0, sum=0; u<=max; u++) sum += table[u];
	DEBUGLOG(2, "total nb elts: %u", sum);
	for (u=0; u<=max; u++) {
	DEBUGLOG(2, "%2u: %5u (%.2f)",
	u, table[u], ZSTD_fWeight(sum) - ZSTD_fWeight(table[u]) );
	}
	}

	#endif


	#if defined (__cplusplus)
	}
	#endif

	/* ===============================================================
	* Shared internal declarations
	* These prototypes may be called from sources not in lib/compress
	* =============================================================== */

	/* ZSTD_loadCEntropy() :
	* dict : must point at beginning of a valid zstd dictionary.
	* return : size of dictionary header (size of magic number + dict ID + entropy tables)
	* assumptions : magic number supposed already checked
	* and dictSize >= 8 */
	size_t ZSTD_loadCEntropy(ZSTD_compressedBlockState_t* bs, void* workspace,
	short* offcodeNCount, unsigned* offcodeMaxValue,
	const void* const dict, size_t dictSize);

	void ZSTD_reset_compressedBlockState(ZSTD_compressedBlockState_t* bs);

	/* ==============================================================
	* Private declarations
	* These prototypes shall only be called from within lib/compress
	* ============================================================== */

	/* ZSTD_getCParamsFromCCtxParams() :
	* cParams are built depending on compressionLevel, src size hints,
	* LDM and manually set compression parameters.
	* Note: srcSizeHint == 0 means 0!
	*/
	ZSTD_compressionParameters ZSTD_getCParamsFromCCtxParams(
	const ZSTD_CCtx_params* CCtxParams, U64 srcSizeHint, size_t dictSize);

	/*! ZSTD_initCStream_internal() :
	* Private use only. Init streaming operation.
	* expects params to be valid.
	* must receive dict, or cdict, or none, but not both.
	* @return : 0, or an error code */
	size_t ZSTD_initCStream_internal(ZSTD_CStream* zcs,
	const void* dict, size_t dictSize,
	const ZSTD_CDict* cdict,
	const ZSTD_CCtx_params* params, unsigned long long pledgedSrcSize);

	void ZSTD_resetSeqStore(seqStore_t* ssPtr);

	/*! ZSTD_getCParamsFromCDict() :
	* as the name implies */
	ZSTD_compressionParameters ZSTD_getCParamsFromCDict(const ZSTD_CDict* cdict);

	/* ZSTD_compressBegin_advanced_internal() :
	* Private use only. To be called from zstdmt_compress.c. */
	size_t ZSTD_compressBegin_advanced_internal(ZSTD_CCtx* cctx,
	const void* dict, size_t dictSize,
	ZSTD_dictContentType_e dictContentType,
	ZSTD_dictTableLoadMethod_e dtlm,
	const ZSTD_CDict* cdict,
	const ZSTD_CCtx_params* params,
	unsigned long long pledgedSrcSize);

	/* ZSTD_compress_advanced_internal() :
	* Private use only. To be called from zstdmt_compress.c. */
	size_t ZSTD_compress_advanced_internal(ZSTD_CCtx* cctx,
	void* dst, size_t dstCapacity,
	const void* src, size_t srcSize,
	const void* dict,size_t dictSize,
	const ZSTD_CCtx_params* params);


	/* ZSTD_writeLastEmptyBlock() :
	* output an empty Block with end-of-frame mark to complete a frame
	* @return : size of data written into `dst` (== ZSTD_blockHeaderSize (defined in zstd_internal.h))
	* or an error code if `dstCapacity` is too small (<ZSTD_blockHeaderSize)
	*/
	size_t ZSTD_writeLastEmptyBlock(void* dst, size_t dstCapacity);


	/* ZSTD_referenceExternalSequences() :
	* Must be called before starting a compression operation.
	* seqs must parse a prefix of the source.
	* This cannot be used when long range matching is enabled.
	* Zstd will use these sequences, and pass the literals to a secondary block
	* compressor.
	* @return : An error code on failure.
	* NOTE: seqs are not verified! Invalid sequences can cause out-of-bounds memory
	* access and data corruption.
	*/
	size_t ZSTD_referenceExternalSequences(ZSTD_CCtx* cctx, rawSeq* seq, size_t nbSeq);

	/** ZSTD_cycleLog() :
	* condition for correct operation : hashLog > 1 */
	U32 ZSTD_cycleLog(U32 hashLog, ZSTD_strategy strat);

	#endif /* ZSTD_COMPRESS_H */
	/** ended inlining zstd_compress_internal.h **/


	size_t ZSTD_noCompressLiterals (void* dst, size_t dstCapacity, const void* src, size_t srcSize);

	size_t ZSTD_compressRleLiteralsBlock (void* dst, size_t dstCapacity, const void* src, size_t srcSize);

	size_t ZSTD_compressLiterals (ZSTD_hufCTables_t const* prevHuf,
	ZSTD_hufCTables_t* nextHuf,
	ZSTD_strategy strategy, int disableLiteralCompression,
	void* dst, size_t dstCapacity,
	const void* src, size_t srcSize,
	void* entropyWorkspace, size_t entropyWorkspaceSize,
	const int bmi2);

	#endif /* ZSTD_COMPRESS_LITERALS_H */
	/** ended inlining zstd_compress_literals.h **/

	size_t ZSTD_noCompressLiterals (void* dst, size_t dstCapacity, const void* src, size_t srcSize)
	{
	BYTE* const ostart = (BYTE* const)dst;
	U32 const flSize = 1 + (srcSize>31) + (srcSize>4095);

	RETURN_ERROR_IF(srcSize + flSize > dstCapacity, dstSize_tooSmall, "");

	switch(flSize)
	{
	case 1: /* 2 - 1 - 5 */
	ostart[0] = (BYTE)((U32)set_basic + (srcSize<<3));
	break;
	case 2: /* 2 - 2 - 12 */
	MEM_writeLE16(ostart, (U16)((U32)set_basic + (1<<2) + (srcSize<<4)));
	break;
	case 3: /* 2 - 2 - 20 */
	MEM_writeLE32(ostart, (U32)((U32)set_basic + (3<<2) + (srcSize<<4)));
	break;
	default: /* not necessary : flSize is {1,2,3} */
	assert(0);
	}

	memcpy(ostart + flSize, src, srcSize);
	DEBUGLOG(5, "Raw literals: %u -> %u", (U32)srcSize, (U32)(srcSize + flSize));
	return srcSize + flSize;
	}

	size_t ZSTD_compressRleLiteralsBlock (void* dst, size_t dstCapacity, const void* src, size_t srcSize)
	{
	BYTE* const ostart = (BYTE* const)dst;
	U32 const flSize = 1 + (srcSize>31) + (srcSize>4095);

	(void)dstCapacity; /* dstCapacity already guaranteed to be >=4, hence large enough */

	switch(flSize)
	{
	case 1: /* 2 - 1 - 5 */
	ostart[0] = (BYTE)((U32)set_rle + (srcSize<<3));
	break;
	case 2: /* 2 - 2 - 12 */
	MEM_writeLE16(ostart, (U16)((U32)set_rle + (1<<2) + (srcSize<<4)));
	break;
	case 3: /* 2 - 2 - 20 */
	MEM_writeLE32(ostart, (U32)((U32)set_rle + (3<<2) + (srcSize<<4)));
	break;
	default: /* not necessary : flSize is {1,2,3} */
	assert(0);
	}

	ostart[flSize] = (const BYTE)src;
	DEBUGLOG(5, "RLE literals: %u -> %u", (U32)srcSize, (U32)flSize + 1);
	return flSize+1;
	}

	size_t ZSTD_compressLiterals (ZSTD_hufCTables_t const* prevHuf,
	ZSTD_hufCTables_t* nextHuf,
	ZSTD_strategy strategy, int disableLiteralCompression,
	void* dst, size_t dstCapacity,
	const void* src, size_t srcSize,
	void* entropyWorkspace, size_t entropyWorkspaceSize,
	const int bmi2)
	{
	size_t const minGain = ZSTD_minGain(srcSize, strategy);
	size_t const lhSize = 3 + (srcSize >= 1 KB) + (srcSize >= 16 KB);
	BYTE* const ostart = (BYTE*)dst;
	U32 singleStream = srcSize < 256;
	symbolEncodingType_e hType = set_compressed;
	size_t cLitSize;

	DEBUGLOG(5,"ZSTD_compressLiterals (disableLiteralCompression=%i srcSize=%u)",
	disableLiteralCompression, (U32)srcSize);

	/* Prepare nextEntropy assuming reusing the existing table */
	memcpy(nextHuf, prevHuf, sizeof(*prevHuf));

	if (disableLiteralCompression)
	return ZSTD_noCompressLiterals(dst, dstCapacity, src, srcSize);

	/* small ? don't even attempt compression (speed opt) */
	# define COMPRESS_LITERALS_SIZE_MIN 63
	{ size_t const minLitSize = (prevHuf->repeatMode == HUF_repeat_valid) ? 6 : COMPRESS_LITERALS_SIZE_MIN;
	if (srcSize <= minLitSize) return ZSTD_noCompressLiterals(dst, dstCapacity, src, srcSize);
	}

	RETURN_ERROR_IF(dstCapacity < lhSize+1, dstSize_tooSmall, "not enough space for compression");
	{ HUF_repeat repeat = prevHuf->repeatMode;
	int const preferRepeat = strategy < ZSTD_lazy ? srcSize <= 1024 : 0;
	if (repeat == HUF_repeat_valid && lhSize == 3) singleStream = 1;
	cLitSize = singleStream ?
	HUF_compress1X_repeat(
	ostart+lhSize, dstCapacity-lhSize, src, srcSize,
	HUF_SYMBOLVALUE_MAX, HUF_TABLELOG_DEFAULT, entropyWorkspace, entropyWorkspaceSize,
	(HUF_CElt*)nextHuf->CTable, &repeat, preferRepeat, bmi2) :
	HUF_compress4X_repeat(
	ostart+lhSize, dstCapacity-lhSize, src, srcSize,
	HUF_SYMBOLVALUE_MAX, HUF_TABLELOG_DEFAULT, entropyWorkspace, entropyWorkspaceSize,
	(HUF_CElt*)nextHuf->CTable, &repeat, preferRepeat, bmi2);
	if (repeat != HUF_repeat_none) {
	/* reused the existing table */
	DEBUGLOG(5, "Reusing previous huffman table");
	hType = set_repeat;
	}
	}

	if ((cLitSize==0) \| (cLitSize >= srcSize - minGain) \| ERR_isError(cLitSize)) {
	memcpy(nextHuf, prevHuf, sizeof(*prevHuf));
	return ZSTD_noCompressLiterals(dst, dstCapacity, src, srcSize);
	}
	if (cLitSize==1) {
	memcpy(nextHuf, prevHuf, sizeof(*prevHuf));
	return ZSTD_compressRleLiteralsBlock(dst, dstCapacity, src, srcSize);
	}

	if (hType == set_compressed) {
	/* using a newly constructed table */
	nextHuf->repeatMode = HUF_repeat_check;
	}

	/* Build header */
	switch(lhSize)
	{
	case 3: /* 2 - 2 - 10 - 10 */
	{ U32 const lhc = hType + ((!singleStream) << 2) + ((U32)srcSize<<4) + ((U32)cLitSize<<14);
	MEM_writeLE24(ostart, lhc);
	break;
	}
	case 4: /* 2 - 2 - 14 - 14 */
	{ U32 const lhc = hType + (2 << 2) + ((U32)srcSize<<4) + ((U32)cLitSize<<18);
	MEM_writeLE32(ostart, lhc);
	break;
	}
	case 5: /* 2 - 2 - 18 - 18 */
	{ U32 const lhc = hType + (3 << 2) + ((U32)srcSize<<4) + ((U32)cLitSize<<22);
	MEM_writeLE32(ostart, lhc);
	ostart[4] = (BYTE)(cLitSize >> 10);
	break;
	}
	default: /* not possible : lhSize is {3,4,5} */
	assert(0);
	}
	DEBUGLOG(5, "Compressed literals: %u -> %u", (U32)srcSize, (U32)(lhSize+cLitSize));
	return lhSize+cLitSize;
	}
	/** ended inlining compress/zstd_compress_literals.c **/
	/** start inlining compress/zstd_compress_sequences.c **/
	/*
	* Copyright (c) 2016-2020, Yann Collet, Facebook, Inc.
	* All rights reserved.
	*
	* This source code is licensed under both the BSD-style license (found in the
	* LICENSE file in the root directory of this source tree) and the GPLv2 (found
	* in the COPYING file in the root directory of this source tree).
	* You may select, at your option, one of the above-listed licenses.
	*/

	/-************************************
	* Dependencies
	***************************************/
	/** start inlining zstd_compress_sequences.h **/
	/*
	* Copyright (c) 2016-2020, Yann Collet, Facebook, Inc.
	* All rights reserved.
	*
	* This source code is licensed under both the BSD-style license (found in the
	* LICENSE file in the root directory of this source tree) and the GPLv2 (found
	* in the COPYING file in the root directory of this source tree).
	* You may select, at your option, one of the above-listed licenses.
	*/

	#ifndef ZSTD_COMPRESS_SEQUENCES_H
	#define ZSTD_COMPRESS_SEQUENCES_H

	/** skipping file: ../common/fse.h **/
	/** skipping file: ../common/zstd_internal.h **/

	typedef enum {
	ZSTD_defaultDisallowed = 0,
	ZSTD_defaultAllowed = 1
	} ZSTD_defaultPolicy_e;

	symbolEncodingType_e
	ZSTD_selectEncodingType(
	FSE_repeat* repeatMode, unsigned const* count, unsigned const max,
	size_t const mostFrequent, size_t nbSeq, unsigned const FSELog,
	FSE_CTable const* prevCTable,
	short const* defaultNorm, U32 defaultNormLog,
	ZSTD_defaultPolicy_e const isDefaultAllowed,
	ZSTD_strategy const strategy);

	size_t
	ZSTD_buildCTable(void* dst, size_t dstCapacity,
	FSE_CTable* nextCTable, U32 FSELog, symbolEncodingType_e type,
	unsigned* count, U32 max,
	const BYTE* codeTable, size_t nbSeq,
	const S16* defaultNorm, U32 defaultNormLog, U32 defaultMax,
	const FSE_CTable* prevCTable, size_t prevCTableSize,
	void* entropyWorkspace, size_t entropyWorkspaceSize);

	size_t ZSTD_encodeSequences(
	void* dst, size_t dstCapacity,
	FSE_CTable const* CTable_MatchLength, BYTE const* mlCodeTable,
	FSE_CTable const* CTable_OffsetBits, BYTE const* ofCodeTable,
	FSE_CTable const* CTable_LitLength, BYTE const* llCodeTable,
	seqDef const* sequences, size_t nbSeq, int longOffsets, int bmi2);

	size_t ZSTD_fseBitCost(
	FSE_CTable const* ctable,
	unsigned const* count,
	unsigned const max);

	size_t ZSTD_crossEntropyCost(short const* norm, unsigned accuracyLog,
	unsigned const* count, unsigned const max);
	#endif /* ZSTD_COMPRESS_SEQUENCES_H */
	/** ended inlining zstd_compress_sequences.h **/

	/**
	* -log2(x / 256) lookup table for x in [0, 256).
	* If x == 0: Return 0
	* Else: Return floor(-log2(x / 256) * 256)
	*/
	static unsigned const kInverseProbabilityLog256[256] = {
	0, 2048, 1792, 1642, 1536, 1453, 1386, 1329, 1280, 1236, 1197, 1162,
	1130, 1100, 1073, 1047, 1024, 1001, 980, 960, 941, 923, 906, 889,
	874, 859, 844, 830, 817, 804, 791, 779, 768, 756, 745, 734,
	724, 714, 704, 694, 685, 676, 667, 658, 650, 642, 633, 626,
	618, 610, 603, 595, 588, 581, 574, 567, 561, 554, 548, 542,
	535, 529, 523, 517, 512, 506, 500, 495, 489, 484, 478, 473,
	468, 463, 458, 453, 448, 443, 438, 434, 429, 424, 420, 415,
	411, 407, 402, 398, 394, 390, 386, 382, 377, 373, 370, 366,
	362, 358, 354, 350, 347, 343, 339, 336, 332, 329, 325, 322,
	318, 315, 311, 308, 305, 302, 298, 295, 292, 289, 286, 282,
	279, 276, 273, 270, 267, 264, 261, 258, 256, 253, 250, 247,
	244, 241, 239, 236, 233, 230, 228, 225, 222, 220, 217, 215,
	212, 209, 207, 204, 202, 199, 197, 194, 192, 190, 187, 185,
	182, 180, 178, 175, 173, 171, 168, 166, 164, 162, 159, 157,
	155, 153, 151, 149, 146, 144, 142, 140, 138, 136, 134, 132,
	130, 128, 126, 123, 121, 119, 117, 115, 114, 112, 110, 108,
	106, 104, 102, 100, 98, 96, 94, 93, 91, 89, 87, 85,
	83, 82, 80, 78, 76, 74, 73, 71, 69, 67, 66, 64,
	62, 61, 59, 57, 55, 54, 52, 50, 49, 47, 46, 44,
	42, 41, 39, 37, 36, 34, 33, 31, 30, 28, 26, 25,
	23, 22, 20, 19, 17, 16, 14, 13, 11, 10, 8, 7,
	5, 4, 2, 1,
	};

	static unsigned ZSTD_getFSEMaxSymbolValue(FSE_CTable const* ctable) {
	void const* ptr = ctable;
	U16 const* u16ptr = (U16 const*)ptr;
	U32 const maxSymbolValue = MEM_read16(u16ptr + 1);
	return maxSymbolValue;
	}

	/**
	* Returns the cost in bytes of encoding the normalized count header.
	* Returns an error if any of the helper functions return an error.
	*/
	static size_t ZSTD_NCountCost(unsigned const* count, unsigned const max,
	size_t const nbSeq, unsigned const FSELog)
	{
	BYTE wksp[FSE_NCOUNTBOUND];
	S16 norm[MaxSeq + 1];
	const U32 tableLog = FSE_optimalTableLog(FSELog, nbSeq, max);
	FORWARD_IF_ERROR(FSE_normalizeCount(norm, tableLog, count, nbSeq, max), "");
	return FSE_writeNCount(wksp, sizeof(wksp), norm, max, tableLog);
	}

	/**
	* Returns the cost in bits of encoding the distribution described by count
	* using the entropy bound.
	*/
	static size_t ZSTD_entropyCost(unsigned const* count, unsigned const max, size_t const total)
	{
	unsigned cost = 0;
	unsigned s;
	for (s = 0; s <= max; ++s) {
	unsigned norm = (unsigned)((256 * count[s]) / total);
	if (count[s] != 0 && norm == 0)
	norm = 1;
	assert(count[s] < total);
	cost += count[s] * kInverseProbabilityLog256[norm];
	}
	return cost >> 8;
	}

	/**
	* Returns the cost in bits of encoding the distribution in count using ctable.
	* Returns an error if ctable cannot represent all the symbols in count.
	*/
	size_t ZSTD_fseBitCost(
	FSE_CTable const* ctable,
	unsigned const* count,
	unsigned const max)
	{
	unsigned const kAccuracyLog = 8;
	size_t cost = 0;
	unsigned s;
	FSE_CState_t cstate;
	FSE_initCState(&cstate, ctable);
	if (ZSTD_getFSEMaxSymbolValue(ctable) < max) {
	DEBUGLOG(5, "Repeat FSE_CTable has maxSymbolValue %u < %u",
	ZSTD_getFSEMaxSymbolValue(ctable), max);
	return ERROR(GENERIC);
	}
	for (s = 0; s <= max; ++s) {
	unsigned const tableLog = cstate.stateLog;
	unsigned const badCost = (tableLog + 1) << kAccuracyLog;
	unsigned const bitCost = FSE_bitCost(cstate.symbolTT, tableLog, s, kAccuracyLog);
	if (count[s] == 0)
	continue;
	if (bitCost >= badCost) {
	DEBUGLOG(5, "Repeat FSE_CTable has Prob[%u] == 0", s);
	return ERROR(GENERIC);
	}
	cost += (size_t)count[s] * bitCost;
	}
	return cost >> kAccuracyLog;
	}

	/**
	* Returns the cost in bits of encoding the distribution in count using the
	* table described by norm. The max symbol support by norm is assumed >= max.
	* norm must be valid for every symbol with non-zero probability in count.
	*/
	size_t ZSTD_crossEntropyCost(short const* norm, unsigned accuracyLog,
	unsigned const* count, unsigned const max)
	{
	unsigned const shift = 8 - accuracyLog;
	size_t cost = 0;
	unsigned s;
	assert(accuracyLog <= 8);
	for (s = 0; s <= max; ++s) {
	unsigned const normAcc = (norm[s] != -1) ? (unsigned)norm[s] : 1;
	unsigned const norm256 = normAcc << shift;
	assert(norm256 > 0);
	assert(norm256 < 256);
	cost += count[s] * kInverseProbabilityLog256[norm256];
	}
	return cost >> 8;
	}

	symbolEncodingType_e
	ZSTD_selectEncodingType(
	FSE_repeat* repeatMode, unsigned const* count, unsigned const max,
	size_t const mostFrequent, size_t nbSeq, unsigned const FSELog,
	FSE_CTable const* prevCTable,
	short const* defaultNorm, U32 defaultNormLog,
	ZSTD_defaultPolicy_e const isDefaultAllowed,
	ZSTD_strategy const strategy)
	{
	ZSTD_STATIC_ASSERT(ZSTD_defaultDisallowed == 0 && ZSTD_defaultAllowed != 0);
	if (mostFrequent == nbSeq) {
	*repeatMode = FSE_repeat_none;
	if (isDefaultAllowed && nbSeq <= 2) {
	/* Prefer set_basic over set_rle when there are 2 or less symbols,
	* since RLE uses 1 byte, but set_basic uses 5-6 bits per symbol.
	* If basic encoding isn't possible, always choose RLE.
	*/
	DEBUGLOG(5, "Selected set_basic");
	return set_basic;
	}
	DEBUGLOG(5, "Selected set_rle");
	return set_rle;
	}
	if (strategy < ZSTD_lazy) {
	if (isDefaultAllowed) {
	size_t const staticFse_nbSeq_max = 1000;
	size_t const mult = 10 - strategy;
	size_t const baseLog = 3;
	size_t const dynamicFse_nbSeq_min = (((size_t)1 << defaultNormLog) * mult) >> baseLog; /* 28-36 for offset, 56-72 for lengths */
	assert(defaultNormLog >= 5 && defaultNormLog <= 6); /* xx_DEFAULTNORMLOG */
	assert(mult <= 9 && mult >= 7);
	if ( (*repeatMode == FSE_repeat_valid)
	&& (nbSeq < staticFse_nbSeq_max) ) {
	DEBUGLOG(5, "Selected set_repeat");
	return set_repeat;
	}
	if ( (nbSeq < dynamicFse_nbSeq_min)
	\|\| (mostFrequent < (nbSeq >> (defaultNormLog-1))) ) {
	DEBUGLOG(5, "Selected set_basic");
	/* The format allows default tables to be repeated, but it isn't useful.
	* When using simple heuristics to select encoding type, we don't want
	* to confuse these tables with dictionaries. When running more careful
	* analysis, we don't need to waste time checking both repeating tables
	* and default tables.
	*/
	*repeatMode = FSE_repeat_none;
	return set_basic;
	}
	}
	} else {
	size_t const basicCost = isDefaultAllowed ? ZSTD_crossEntropyCost(defaultNorm, defaultNormLog, count, max) : ERROR(GENERIC);
	size_t const repeatCost = *repeatMode != FSE_repeat_none ? ZSTD_fseBitCost(prevCTable, count, max) : ERROR(GENERIC);
	size_t const NCountCost = ZSTD_NCountCost(count, max, nbSeq, FSELog);
	size_t const compressedCost = (NCountCost << 3) + ZSTD_entropyCost(count, max, nbSeq);

	if (isDefaultAllowed) {
	assert(!ZSTD_isError(basicCost));
	assert(!(*repeatMode == FSE_repeat_valid && ZSTD_isError(repeatCost)));
	}
	assert(!ZSTD_isError(NCountCost));
	assert(compressedCost < ERROR(maxCode));
	DEBUGLOG(5, "Estimated bit costs: basic=%u\trepeat=%u\tcompressed=%u",
	(unsigned)basicCost, (unsigned)repeatCost, (unsigned)compressedCost);
	if (basicCost <= repeatCost && basicCost <= compressedCost) {
	DEBUGLOG(5, "Selected set_basic");
	assert(isDefaultAllowed);
	*repeatMode = FSE_repeat_none;
	return set_basic;
	}
	if (repeatCost <= compressedCost) {
	DEBUGLOG(5, "Selected set_repeat");
	assert(!ZSTD_isError(repeatCost));
	return set_repeat;
	}
	assert(compressedCost < basicCost && compressedCost < repeatCost);
	}
	DEBUGLOG(5, "Selected set_compressed");
	*repeatMode = FSE_repeat_check;
	return set_compressed;
	}

	size_t
	ZSTD_buildCTable(void* dst, size_t dstCapacity,
	FSE_CTable* nextCTable, U32 FSELog, symbolEncodingType_e type,
	unsigned* count, U32 max,
	const BYTE* codeTable, size_t nbSeq,
	const S16* defaultNorm, U32 defaultNormLog, U32 defaultMax,
	const FSE_CTable* prevCTable, size_t prevCTableSize,
	void* entropyWorkspace, size_t entropyWorkspaceSize)
	{
	BYTE* op = (BYTE*)dst;
	const BYTE* const oend = op + dstCapacity;
	DEBUGLOG(6, "ZSTD_buildCTable (dstCapacity=%u)", (unsigned)dstCapacity);

	switch (type) {
	case set_rle:
	FORWARD_IF_ERROR(FSE_buildCTable_rle(nextCTable, (BYTE)max), "");
	RETURN_ERROR_IF(dstCapacity==0, dstSize_tooSmall, "not enough space");
	*op = codeTable[0];
	return 1;
	case set_repeat:
	memcpy(nextCTable, prevCTable, prevCTableSize);
	return 0;
	case set_basic:
	FORWARD_IF_ERROR(FSE_buildCTable_wksp(nextCTable, defaultNorm, defaultMax, defaultNormLog, entropyWorkspace, entropyWorkspaceSize), ""); /* note : could be pre-calculated */
	return 0;
	case set_compressed: {
	S16 norm[MaxSeq + 1];
	size_t nbSeq_1 = nbSeq;
	const U32 tableLog = FSE_optimalTableLog(FSELog, nbSeq, max);
	if (count[codeTable[nbSeq-1]] > 1) {
	count[codeTable[nbSeq-1]]--;
	nbSeq_1--;
	}
	assert(nbSeq_1 > 1);
	FORWARD_IF_ERROR(FSE_normalizeCount(norm, tableLog, count, nbSeq_1, max), "");
	{ size_t const NCountSize = FSE_writeNCount(op, oend - op, norm, max, tableLog); /* overflow protected */
	FORWARD_IF_ERROR(NCountSize, "FSE_writeNCount failed");
	FORWARD_IF_ERROR(FSE_buildCTable_wksp(nextCTable, norm, max, tableLog, entropyWorkspace, entropyWorkspaceSize), "");
	return NCountSize;
	}
	}
	default: assert(0); RETURN_ERROR(GENERIC, "impossible to reach");
	}
	}

	FORCE_INLINE_TEMPLATE size_t
	ZSTD_encodeSequences_body(
	void* dst, size_t dstCapacity,
	FSE_CTable const* CTable_MatchLength, BYTE const* mlCodeTable,
	FSE_CTable const* CTable_OffsetBits, BYTE const* ofCodeTable,
	FSE_CTable const* CTable_LitLength, BYTE const* llCodeTable,
	seqDef const* sequences, size_t nbSeq, int longOffsets)
	{
	BIT_CStream_t blockStream;
	FSE_CState_t stateMatchLength;
	FSE_CState_t stateOffsetBits;
	FSE_CState_t stateLitLength;

	RETURN_ERROR_IF(
	ERR_isError(BIT_initCStream(&blockStream, dst, dstCapacity)),
	dstSize_tooSmall, "not enough space remaining");
	DEBUGLOG(6, "available space for bitstream : %i (dstCapacity=%u)",
	(int)(blockStream.endPtr - blockStream.startPtr),
	(unsigned)dstCapacity);

	/* first symbols */
	FSE_initCState2(&stateMatchLength, CTable_MatchLength, mlCodeTable[nbSeq-1]);
	FSE_initCState2(&stateOffsetBits, CTable_OffsetBits, ofCodeTable[nbSeq-1]);
	FSE_initCState2(&stateLitLength, CTable_LitLength, llCodeTable[nbSeq-1]);
	BIT_addBits(&blockStream, sequences[nbSeq-1].litLength, LL_bits[llCodeTable[nbSeq-1]]);
	if (MEM_32bits()) BIT_flushBits(&blockStream);
	BIT_addBits(&blockStream, sequences[nbSeq-1].matchLength, ML_bits[mlCodeTable[nbSeq-1]]);
	if (MEM_32bits()) BIT_flushBits(&blockStream);
	if (longOffsets) {
	U32 const ofBits = ofCodeTable[nbSeq-1];
	unsigned const extraBits = ofBits - MIN(ofBits, STREAM_ACCUMULATOR_MIN-1);
	if (extraBits) {
	BIT_addBits(&blockStream, sequences[nbSeq-1].offset, extraBits);
	BIT_flushBits(&blockStream);
	}
	BIT_addBits(&blockStream, sequences[nbSeq-1].offset >> extraBits,
	ofBits - extraBits);
	} else {
	BIT_addBits(&blockStream, sequences[nbSeq-1].offset, ofCodeTable[nbSeq-1]);
	}
	BIT_flushBits(&blockStream);

	{ size_t n;
	for (n=nbSeq-2 ; n<nbSeq ; n--) { /* intentional underflow */
	BYTE const llCode = llCodeTable[n];
	BYTE const ofCode = ofCodeTable[n];
	BYTE const mlCode = mlCodeTable[n];
	U32 const llBits = LL_bits[llCode];
	U32 const ofBits = ofCode;
	U32 const mlBits = ML_bits[mlCode];
	DEBUGLOG(6, "encoding: litlen:%2u - matchlen:%2u - offCode:%7u",
	(unsigned)sequences[n].litLength,
	(unsigned)sequences[n].matchLength + MINMATCH,
	(unsigned)sequences[n].offset);
	/* 32b/ / 64b*/
	/* (7)/ / (7)*/
	FSE_encodeSymbol(&blockStream, &stateOffsetBits, ofCode); /* 15 / / 15 */
	FSE_encodeSymbol(&blockStream, &stateMatchLength, mlCode); /* 24 / / 24 */
	if (MEM_32bits()) BIT_flushBits(&blockStream); /* (7)*/
	FSE_encodeSymbol(&blockStream, &stateLitLength, llCode); /* 16 / / 33 */
	if (MEM_32bits() \|\| (ofBits+mlBits+llBits >= 64-7-(LLFSELog+MLFSELog+OffFSELog)))
	BIT_flushBits(&blockStream); /* (7)*/
	BIT_addBits(&blockStream, sequences[n].litLength, llBits);
	if (MEM_32bits() && ((llBits+mlBits)>24)) BIT_flushBits(&blockStream);
	BIT_addBits(&blockStream, sequences[n].matchLength, mlBits);
	if (MEM_32bits() \|\| (ofBits+mlBits+llBits > 56)) BIT_flushBits(&blockStream);
	if (longOffsets) {
	unsigned const extraBits = ofBits - MIN(ofBits, STREAM_ACCUMULATOR_MIN-1);
	if (extraBits) {
	BIT_addBits(&blockStream, sequences[n].offset, extraBits);
	BIT_flushBits(&blockStream); /* (7)*/
	}
	BIT_addBits(&blockStream, sequences[n].offset >> extraBits,
	ofBits - extraBits); /* 31 */
	} else {
	BIT_addBits(&blockStream, sequences[n].offset, ofBits); /* 31 */
	}
	BIT_flushBits(&blockStream); /* (7)*/
	DEBUGLOG(7, "remaining space : %i", (int)(blockStream.endPtr - blockStream.ptr));
	} }

	DEBUGLOG(6, "ZSTD_encodeSequences: flushing ML state with %u bits", stateMatchLength.stateLog);
	FSE_flushCState(&blockStream, &stateMatchLength);
	DEBUGLOG(6, "ZSTD_encodeSequences: flushing Off state with %u bits", stateOffsetBits.stateLog);
	FSE_flushCState(&blockStream, &stateOffsetBits);
	DEBUGLOG(6, "ZSTD_encodeSequences: flushing LL state with %u bits", stateLitLength.stateLog);
	FSE_flushCState(&blockStream, &stateLitLength);

	{ size_t const streamSize = BIT_closeCStream(&blockStream);
	RETURN_ERROR_IF(streamSize==0, dstSize_tooSmall, "not enough space");
	return streamSize;
	}
	}

	static size_t
	ZSTD_encodeSequences_default(
	void* dst, size_t dstCapacity,
	FSE_CTable const* CTable_MatchLength, BYTE const* mlCodeTable,
	FSE_CTable const* CTable_OffsetBits, BYTE const* ofCodeTable,
	FSE_CTable const* CTable_LitLength, BYTE const* llCodeTable,
	seqDef const* sequences, size_t nbSeq, int longOffsets)
	{
	return ZSTD_encodeSequences_body(dst, dstCapacity,
	CTable_MatchLength, mlCodeTable,
	CTable_OffsetBits, ofCodeTable,
	CTable_LitLength, llCodeTable,
	sequences, nbSeq, longOffsets);
	}


	#if DYNAMIC_BMI2

	static TARGET_ATTRIBUTE("bmi2") size_t
	ZSTD_encodeSequences_bmi2(
	void* dst, size_t dstCapacity,
	FSE_CTable const* CTable_MatchLength, BYTE const* mlCodeTable,
	FSE_CTable const* CTable_OffsetBits, BYTE const* ofCodeTable,
	FSE_CTable const* CTable_LitLength, BYTE const* llCodeTable,
	seqDef const* sequences, size_t nbSeq, int longOffsets)
	{
	return ZSTD_encodeSequences_body(dst, dstCapacity,
	CTable_MatchLength, mlCodeTable,
	CTable_OffsetBits, ofCodeTable,
	CTable_LitLength, llCodeTable,
	sequences, nbSeq, longOffsets);
	}

	#endif

	size_t ZSTD_encodeSequences(
	void* dst, size_t dstCapacity,
	FSE_CTable const* CTable_MatchLength, BYTE const* mlCodeTable,
	FSE_CTable const* CTable_OffsetBits, BYTE const* ofCodeTable,
	FSE_CTable const* CTable_LitLength, BYTE const* llCodeTable,
	seqDef const* sequences, size_t nbSeq, int longOffsets, int bmi2)
	{
	DEBUGLOG(5, "ZSTD_encodeSequences: dstCapacity = %u", (unsigned)dstCapacity);
	#if DYNAMIC_BMI2
	if (bmi2) {
	return ZSTD_encodeSequences_bmi2(dst, dstCapacity,
	CTable_MatchLength, mlCodeTable,
	CTable_OffsetBits, ofCodeTable,
	CTable_LitLength, llCodeTable,
	sequences, nbSeq, longOffsets);
	}
	#endif
	(void)bmi2;
	return ZSTD_encodeSequences_default(dst, dstCapacity,
	CTable_MatchLength, mlCodeTable,
	CTable_OffsetBits, ofCodeTable,
	CTable_LitLength, llCodeTable,
	sequences, nbSeq, longOffsets);
	}
	/** ended inlining compress/zstd_compress_sequences.c **/
	/** start inlining compress/zstd_compress_superblock.c **/
	/*
	* Copyright (c) 2016-2020, Yann Collet, Facebook, Inc.
	* All rights reserved.
	*
	* This source code is licensed under both the BSD-style license (found in the
	* LICENSE file in the root directory of this source tree) and the GPLv2 (found
	* in the COPYING file in the root directory of this source tree).
	* You may select, at your option, one of the above-listed licenses.
	*/

	/-************************************
	* Dependencies
	***************************************/
	/** start inlining zstd_compress_superblock.h **/
	/*
	* Copyright (c) 2016-2020, Yann Collet, Facebook, Inc.
	* All rights reserved.
	*
	* This source code is licensed under both the BSD-style license (found in the
	* LICENSE file in the root directory of this source tree) and the GPLv2 (found
	* in the COPYING file in the root directory of this source tree).
	* You may select, at your option, one of the above-listed licenses.
	*/

	#ifndef ZSTD_COMPRESS_ADVANCED_H
	#define ZSTD_COMPRESS_ADVANCED_H

	/-************************************
	* Dependencies
	***************************************/

	/** skipping file: ../zstd.h **/

	/-************************************
	* Target Compressed Block Size
	***************************************/

	/* ZSTD_compressSuperBlock() :
	* Used to compress a super block when targetCBlockSize is being used.
	* The given block will be compressed into multiple sub blocks that are around targetCBlockSize. */
	size_t ZSTD_compressSuperBlock(ZSTD_CCtx* zc,
	void* dst, size_t dstCapacity,
	void const* src, size_t srcSize,
	unsigned lastBlock);

	#endif /* ZSTD_COMPRESS_ADVANCED_H */
	/** ended inlining zstd_compress_superblock.h **/

	/** skipping file: ../common/zstd_internal.h **/
	/** skipping file: hist.h **/
	/** skipping file: zstd_compress_internal.h **/
	/** skipping file: zstd_compress_sequences.h **/
	/** skipping file: zstd_compress_literals.h **/

	/-************************************
	* Superblock entropy buffer structs
	***************************************/
	/** ZSTD_hufCTablesMetadata_t :
	* Stores Literals Block Type for a super-block in hType, and
	* huffman tree description in hufDesBuffer.
	* hufDesSize refers to the size of huffman tree description in bytes.
	* This metadata is populated in ZSTD_buildSuperBlockEntropy_literal() */
	typedef struct {
	symbolEncodingType_e hType;
	BYTE hufDesBuffer[500]; /* TODO give name to this value */
	size_t hufDesSize;
	} ZSTD_hufCTablesMetadata_t;

	/** ZSTD_fseCTablesMetadata_t :
	* Stores symbol compression modes for a super-block in {ll, ol, ml}Type, and
	* fse tables in fseTablesBuffer.
	* fseTablesSize refers to the size of fse tables in bytes.
	* This metadata is populated in ZSTD_buildSuperBlockEntropy_sequences() */
	typedef struct {
	symbolEncodingType_e llType;
	symbolEncodingType_e ofType;
	symbolEncodingType_e mlType;
	BYTE fseTablesBuffer[500]; /* TODO give name to this value */
	size_t fseTablesSize;
	size_t lastCountSize; /* This is to account for bug in 1.3.4. More detail in ZSTD_compressSubBlock_sequences() */
	} ZSTD_fseCTablesMetadata_t;

	typedef struct {
	ZSTD_hufCTablesMetadata_t hufMetadata;
	ZSTD_fseCTablesMetadata_t fseMetadata;
	} ZSTD_entropyCTablesMetadata_t;


	/** ZSTD_buildSuperBlockEntropy_literal() :
	* Builds entropy for the super-block literals.
	* Stores literals block type (raw, rle, compressed, repeat) and
	* huffman description table to hufMetadata.
	* @return : size of huffman description table or error code */
	static size_t ZSTD_buildSuperBlockEntropy_literal(void* const src, size_t srcSize,
	const ZSTD_hufCTables_t* prevHuf,
	ZSTD_hufCTables_t* nextHuf,
	ZSTD_hufCTablesMetadata_t* hufMetadata,
	const int disableLiteralsCompression,
	void* workspace, size_t wkspSize)
	{
	BYTE* const wkspStart = (BYTE*)workspace;
	BYTE* const wkspEnd = wkspStart + wkspSize;
	BYTE* const countWkspStart = wkspStart;
	unsigned* const countWksp = (unsigned*)workspace;
	const size_t countWkspSize = (HUF_SYMBOLVALUE_MAX + 1) * sizeof(unsigned);
	BYTE* const nodeWksp = countWkspStart + countWkspSize;
	const size_t nodeWkspSize = wkspEnd-nodeWksp;
	unsigned maxSymbolValue = 255;
	unsigned huffLog = HUF_TABLELOG_DEFAULT;
	HUF_repeat repeat = prevHuf->repeatMode;

	DEBUGLOG(5, "ZSTD_buildSuperBlockEntropy_literal (srcSize=%zu)", srcSize);

	/* Prepare nextEntropy assuming reusing the existing table */
	memcpy(nextHuf, prevHuf, sizeof(*prevHuf));

	if (disableLiteralsCompression) {
	DEBUGLOG(5, "set_basic - disabled");
	hufMetadata->hType = set_basic;
	return 0;
	}

	/* small ? don't even attempt compression (speed opt) */
	# define COMPRESS_LITERALS_SIZE_MIN 63
	{ size_t const minLitSize = (prevHuf->repeatMode == HUF_repeat_valid) ? 6 : COMPRESS_LITERALS_SIZE_MIN;
	if (srcSize <= minLitSize) {
	DEBUGLOG(5, "set_basic - too small");
	hufMetadata->hType = set_basic;
	return 0;
	}
	}

	/* Scan input and build symbol stats */
	{ size_t const largest = HIST_count_wksp (countWksp, &maxSymbolValue, (const BYTE*)src, srcSize, workspace, wkspSize);
	FORWARD_IF_ERROR(largest, "HIST_count_wksp failed");
	if (largest == srcSize) {
	DEBUGLOG(5, "set_rle");
	hufMetadata->hType = set_rle;
	return 0;
	}
	if (largest <= (srcSize >> 7)+4) {
	DEBUGLOG(5, "set_basic - no gain");
	hufMetadata->hType = set_basic;
	return 0;
	}
	}

	/* Validate the previous Huffman table */
	if (repeat == HUF_repeat_check && !HUF_validateCTable((HUF_CElt const*)prevHuf->CTable, countWksp, maxSymbolValue)) {
	repeat = HUF_repeat_none;
	}

	/* Build Huffman Tree */
	memset(nextHuf->CTable, 0, sizeof(nextHuf->CTable));
	huffLog = HUF_optimalTableLog(huffLog, srcSize, maxSymbolValue);
	{ size_t const maxBits = HUF_buildCTable_wksp((HUF_CElt*)nextHuf->CTable, countWksp,
	maxSymbolValue, huffLog,
	nodeWksp, nodeWkspSize);
	FORWARD_IF_ERROR(maxBits, "HUF_buildCTable_wksp");
	huffLog = (U32)maxBits;
	{ /* Build and write the CTable */
	size_t const newCSize = HUF_estimateCompressedSize(
	(HUF_CElt*)nextHuf->CTable, countWksp, maxSymbolValue);
	size_t const hSize = HUF_writeCTable(
	hufMetadata->hufDesBuffer, sizeof(hufMetadata->hufDesBuffer),
	(HUF_CElt*)nextHuf->CTable, maxSymbolValue, huffLog);
	/* Check against repeating the previous CTable */
	if (repeat != HUF_repeat_none) {
	size_t const oldCSize = HUF_estimateCompressedSize(
	(HUF_CElt const*)prevHuf->CTable, countWksp, maxSymbolValue);
	if (oldCSize < srcSize && (oldCSize <= hSize + newCSize \|\| hSize + 12 >= srcSize)) {
	DEBUGLOG(5, "set_repeat - smaller");
	memcpy(nextHuf, prevHuf, sizeof(*prevHuf));
	hufMetadata->hType = set_repeat;
	return 0;
	}
	}
	if (newCSize + hSize >= srcSize) {
	DEBUGLOG(5, "set_basic - no gains");
	memcpy(nextHuf, prevHuf, sizeof(*prevHuf));
	hufMetadata->hType = set_basic;
	return 0;
	}
	DEBUGLOG(5, "set_compressed (hSize=%u)", (U32)hSize);
	hufMetadata->hType = set_compressed;
	nextHuf->repeatMode = HUF_repeat_check;
	return hSize;
	}
	}
	}

	/** ZSTD_buildSuperBlockEntropy_sequences() :
	* Builds entropy for the super-block sequences.
	* Stores symbol compression modes and fse table to fseMetadata.
	* @return : size of fse tables or error code */
	static size_t ZSTD_buildSuperBlockEntropy_sequences(seqStore_t* seqStorePtr,
	const ZSTD_fseCTables_t* prevEntropy,
	ZSTD_fseCTables_t* nextEntropy,
	const ZSTD_CCtx_params* cctxParams,
	ZSTD_fseCTablesMetadata_t* fseMetadata,
	void* workspace, size_t wkspSize)
	{
	BYTE* const wkspStart = (BYTE*)workspace;
	BYTE* const wkspEnd = wkspStart + wkspSize;
	BYTE* const countWkspStart = wkspStart;
	unsigned* const countWksp = (unsigned*)workspace;
	const size_t countWkspSize = (MaxSeq + 1) * sizeof(unsigned);
	BYTE* const cTableWksp = countWkspStart + countWkspSize;
	const size_t cTableWkspSize = wkspEnd-cTableWksp;
	ZSTD_strategy const strategy = cctxParams->cParams.strategy;
	FSE_CTable* CTable_LitLength = nextEntropy->litlengthCTable;
	FSE_CTable* CTable_OffsetBits = nextEntropy->offcodeCTable;
	FSE_CTable* CTable_MatchLength = nextEntropy->matchlengthCTable;
	const BYTE* const ofCodeTable = seqStorePtr->ofCode;
	const BYTE* const llCodeTable = seqStorePtr->llCode;
	const BYTE* const mlCodeTable = seqStorePtr->mlCode;
	size_t const nbSeq = seqStorePtr->sequences - seqStorePtr->sequencesStart;
	BYTE* const ostart = fseMetadata->fseTablesBuffer;
	BYTE* const oend = ostart + sizeof(fseMetadata->fseTablesBuffer);
	BYTE* op = ostart;

	assert(cTableWkspSize >= (1 << MaxFSELog) * sizeof(FSE_FUNCTION_TYPE));
	DEBUGLOG(5, "ZSTD_buildSuperBlockEntropy_sequences (nbSeq=%zu)", nbSeq);
	memset(workspace, 0, wkspSize);

	fseMetadata->lastCountSize = 0;
	/* convert length/distances into codes */
	ZSTD_seqToCodes(seqStorePtr);
	/* build CTable for Literal Lengths */
	{ U32 LLtype;
	unsigned max = MaxLL;
	size_t const mostFrequent = HIST_countFast_wksp(countWksp, &max, llCodeTable, nbSeq, workspace, wkspSize); /* can't fail */
	DEBUGLOG(5, "Building LL table");
	nextEntropy->litlength_repeatMode = prevEntropy->litlength_repeatMode;
	LLtype = ZSTD_selectEncodingType(&nextEntropy->litlength_repeatMode,
	countWksp, max, mostFrequent, nbSeq,
	LLFSELog, prevEntropy->litlengthCTable,
	LL_defaultNorm, LL_defaultNormLog,
	ZSTD_defaultAllowed, strategy);
	assert(set_basic < set_compressed && set_rle < set_compressed);
	assert(!(LLtype < set_compressed && nextEntropy->litlength_repeatMode != FSE_repeat_none)); /* We don't copy tables */
	{ size_t const countSize = ZSTD_buildCTable(op, oend - op, CTable_LitLength, LLFSELog, (symbolEncodingType_e)LLtype,
	countWksp, max, llCodeTable, nbSeq, LL_defaultNorm, LL_defaultNormLog, MaxLL,
	prevEntropy->litlengthCTable, sizeof(prevEntropy->litlengthCTable),
	cTableWksp, cTableWkspSize);
	FORWARD_IF_ERROR(countSize, "ZSTD_buildCTable for LitLens failed");
	if (LLtype == set_compressed)
	fseMetadata->lastCountSize = countSize;
	op += countSize;
	fseMetadata->llType = (symbolEncodingType_e) LLtype;
	} }
	/* build CTable for Offsets */
	{ U32 Offtype;
	unsigned max = MaxOff;
	size_t const mostFrequent = HIST_countFast_wksp(countWksp, &max, ofCodeTable, nbSeq, workspace, wkspSize); /* can't fail */
	/* We can only use the basic table if max <= DefaultMaxOff, otherwise the offsets are too large */
	ZSTD_defaultPolicy_e const defaultPolicy = (max <= DefaultMaxOff) ? ZSTD_defaultAllowed : ZSTD_defaultDisallowed;
	DEBUGLOG(5, "Building OF table");
	nextEntropy->offcode_repeatMode = prevEntropy->offcode_repeatMode;
	Offtype = ZSTD_selectEncodingType(&nextEntropy->offcode_repeatMode,
	countWksp, max, mostFrequent, nbSeq,
	OffFSELog, prevEntropy->offcodeCTable,
	OF_defaultNorm, OF_defaultNormLog,
	defaultPolicy, strategy);
	assert(!(Offtype < set_compressed && nextEntropy->offcode_repeatMode != FSE_repeat_none)); /* We don't copy tables */
	{ size_t const countSize = ZSTD_buildCTable(op, oend - op, CTable_OffsetBits, OffFSELog, (symbolEncodingType_e)Offtype,
	countWksp, max, ofCodeTable, nbSeq, OF_defaultNorm, OF_defaultNormLog, DefaultMaxOff,
	prevEntropy->offcodeCTable, sizeof(prevEntropy->offcodeCTable),
	cTableWksp, cTableWkspSize);
	FORWARD_IF_ERROR(countSize, "ZSTD_buildCTable for Offsets failed");
	if (Offtype == set_compressed)
	fseMetadata->lastCountSize = countSize;
	op += countSize;
	fseMetadata->ofType = (symbolEncodingType_e) Offtype;
	} }
	/* build CTable for MatchLengths */
	{ U32 MLtype;
	unsigned max = MaxML;
	size_t const mostFrequent = HIST_countFast_wksp(countWksp, &max, mlCodeTable, nbSeq, workspace, wkspSize); /* can't fail */
	DEBUGLOG(5, "Building ML table (remaining space : %i)", (int)(oend-op));
	nextEntropy->matchlength_repeatMode = prevEntropy->matchlength_repeatMode;
	MLtype = ZSTD_selectEncodingType(&nextEntropy->matchlength_repeatMode,
	countWksp, max, mostFrequent, nbSeq,
	MLFSELog, prevEntropy->matchlengthCTable,
	ML_defaultNorm, ML_defaultNormLog,
	ZSTD_defaultAllowed, strategy);
	assert(!(MLtype < set_compressed && nextEntropy->matchlength_repeatMode != FSE_repeat_none)); /* We don't copy tables */
	{ size_t const countSize = ZSTD_buildCTable(op, oend - op, CTable_MatchLength, MLFSELog, (symbolEncodingType_e)MLtype,
	countWksp, max, mlCodeTable, nbSeq, ML_defaultNorm, ML_defaultNormLog, MaxML,
	prevEntropy->matchlengthCTable, sizeof(prevEntropy->matchlengthCTable),
	cTableWksp, cTableWkspSize);
	FORWARD_IF_ERROR(countSize, "ZSTD_buildCTable for MatchLengths failed");
	if (MLtype == set_compressed)
	fseMetadata->lastCountSize = countSize;
	op += countSize;
	fseMetadata->mlType = (symbolEncodingType_e) MLtype;
	} }
	assert((size_t) (op-ostart) <= sizeof(fseMetadata->fseTablesBuffer));
	return op-ostart;
	}


	/** ZSTD_buildSuperBlockEntropy() :
	* Builds entropy for the super-block.
	* @return : 0 on success or error code */
	static size_t
	ZSTD_buildSuperBlockEntropy(seqStore_t* seqStorePtr,
	const ZSTD_entropyCTables_t* prevEntropy,
	ZSTD_entropyCTables_t* nextEntropy,
	const ZSTD_CCtx_params* cctxParams,
	ZSTD_entropyCTablesMetadata_t* entropyMetadata,
	void* workspace, size_t wkspSize)
	{
	size_t const litSize = seqStorePtr->lit - seqStorePtr->litStart;
	DEBUGLOG(5, "ZSTD_buildSuperBlockEntropy");
	entropyMetadata->hufMetadata.hufDesSize =
	ZSTD_buildSuperBlockEntropy_literal(seqStorePtr->litStart, litSize,
	&prevEntropy->huf, &nextEntropy->huf,
	&entropyMetadata->hufMetadata,
	ZSTD_disableLiteralsCompression(cctxParams),
	workspace, wkspSize);
	FORWARD_IF_ERROR(entropyMetadata->hufMetadata.hufDesSize, "ZSTD_buildSuperBlockEntropy_literal failed");
	entropyMetadata->fseMetadata.fseTablesSize =
	ZSTD_buildSuperBlockEntropy_sequences(seqStorePtr,
	&prevEntropy->fse, &nextEntropy->fse,
	cctxParams,
	&entropyMetadata->fseMetadata,
	workspace, wkspSize);
	FORWARD_IF_ERROR(entropyMetadata->fseMetadata.fseTablesSize, "ZSTD_buildSuperBlockEntropy_sequences failed");
	return 0;
	}

	/** ZSTD_compressSubBlock_literal() :
	* Compresses literals section for a sub-block.
	* When we have to write the Huffman table we will sometimes choose a header
	* size larger than necessary. This is because we have to pick the header size
	* before we know the table size + compressed size, so we have a bound on the
	* table size. If we guessed incorrectly, we fall back to uncompressed literals.
	*
	* We write the header when writeEntropy=1 and set entropyWrriten=1 when we succeeded
	* in writing the header, otherwise it is set to 0.
	*
	* hufMetadata->hType has literals block type info.
	* If it is set_basic, all sub-blocks literals section will be Raw_Literals_Block.
	* If it is set_rle, all sub-blocks literals section will be RLE_Literals_Block.
	* If it is set_compressed, first sub-block's literals section will be Compressed_Literals_Block
	* If it is set_compressed, first sub-block's literals section will be Treeless_Literals_Block
	* and the following sub-blocks' literals sections will be Treeless_Literals_Block.
	* @return : compressed size of literals section of a sub-block
	* Or 0 if it unable to compress.
	* Or error code */
	static size_t ZSTD_compressSubBlock_literal(const HUF_CElt* hufTable,
	const ZSTD_hufCTablesMetadata_t* hufMetadata,
	const BYTE* literals, size_t litSize,
	void* dst, size_t dstSize,
	const int bmi2, int writeEntropy, int* entropyWritten)
	{
	size_t const header = writeEntropy ? 200 : 0;
	size_t const lhSize = 3 + (litSize >= (1 KB - header)) + (litSize >= (16 KB - header));
	BYTE* const ostart = (BYTE*)dst;
	BYTE* const oend = ostart + dstSize;
	BYTE* op = ostart + lhSize;
	U32 const singleStream = lhSize == 3;
	symbolEncodingType_e hType = writeEntropy ? hufMetadata->hType : set_repeat;
	size_t cLitSize = 0;

	(void)bmi2; /* TODO bmi2... */

	DEBUGLOG(5, "ZSTD_compressSubBlock_literal (litSize=%zu, lhSize=%zu, writeEntropy=%d)", litSize, lhSize, writeEntropy);

	*entropyWritten = 0;
	if (litSize == 0 \|\| hufMetadata->hType == set_basic) {
	DEBUGLOG(5, "ZSTD_compressSubBlock_literal using raw literal");
	return ZSTD_noCompressLiterals(dst, dstSize, literals, litSize);
	} else if (hufMetadata->hType == set_rle) {
	DEBUGLOG(5, "ZSTD_compressSubBlock_literal using rle literal");
	return ZSTD_compressRleLiteralsBlock(dst, dstSize, literals, litSize);
	}

	assert(litSize > 0);
	assert(hufMetadata->hType == set_compressed \|\| hufMetadata->hType == set_repeat);

	if (writeEntropy && hufMetadata->hType == set_compressed) {
	memcpy(op, hufMetadata->hufDesBuffer, hufMetadata->hufDesSize);
	op += hufMetadata->hufDesSize;
	cLitSize += hufMetadata->hufDesSize;
	DEBUGLOG(5, "ZSTD_compressSubBlock_literal (hSize=%zu)", hufMetadata->hufDesSize);
	}

	/* TODO bmi2 */
	{ const size_t cSize = singleStream ? HUF_compress1X_usingCTable(op, oend-op, literals, litSize, hufTable)
	: HUF_compress4X_usingCTable(op, oend-op, literals, litSize, hufTable);
	op += cSize;
	cLitSize += cSize;
	if (cSize == 0 \|\| ERR_isError(cSize)) {
	DEBUGLOG(5, "Failed to write entropy tables %s", ZSTD_getErrorName(cSize));
	return 0;
	}
	/* If we expand and we aren't writing a header then emit uncompressed */
	if (!writeEntropy && cLitSize >= litSize) {
	DEBUGLOG(5, "ZSTD_compressSubBlock_literal using raw literal because uncompressible");
	return ZSTD_noCompressLiterals(dst, dstSize, literals, litSize);
	}
	/* If we are writing headers then allow expansion that doesn't change our header size. */
	if (lhSize < (size_t)(3 + (cLitSize >= 1 KB) + (cLitSize >= 16 KB))) {
	assert(cLitSize > litSize);
	DEBUGLOG(5, "Literals expanded beyond allowed header size");
	return ZSTD_noCompressLiterals(dst, dstSize, literals, litSize);
	}
	DEBUGLOG(5, "ZSTD_compressSubBlock_literal (cSize=%zu)", cSize);
	}

	/* Build header */
	switch(lhSize)
	{
	case 3: /* 2 - 2 - 10 - 10 */
	{ U32 const lhc = hType + ((!singleStream) << 2) + ((U32)litSize<<4) + ((U32)cLitSize<<14);
	MEM_writeLE24(ostart, lhc);
	break;
	}
	case 4: /* 2 - 2 - 14 - 14 */
	{ U32 const lhc = hType + (2 << 2) + ((U32)litSize<<4) + ((U32)cLitSize<<18);
	MEM_writeLE32(ostart, lhc);
	break;
	}
	case 5: /* 2 - 2 - 18 - 18 */
	{ U32 const lhc = hType + (3 << 2) + ((U32)litSize<<4) + ((U32)cLitSize<<22);
	MEM_writeLE32(ostart, lhc);
	ostart[4] = (BYTE)(cLitSize >> 10);
	break;
	}
	default: /* not possible : lhSize is {3,4,5} */
	assert(0);
	}
	*entropyWritten = 1;
	DEBUGLOG(5, "Compressed literals: %u -> %u", (U32)litSize, (U32)(op-ostart));
	return op-ostart;
	}

	static size_t ZSTD_seqDecompressedSize(seqStore_t const* seqStore, const seqDef* sequences, size_t nbSeq, size_t litSize, int lastSequence) {
	const seqDef* const sstart = sequences;
	const seqDef* const send = sequences + nbSeq;
	const seqDef* sp = sstart;
	size_t matchLengthSum = 0;
	size_t litLengthSum = 0;
	while (send-sp > 0) {
	ZSTD_sequenceLength const seqLen = ZSTD_getSequenceLength(seqStore, sp);
	litLengthSum += seqLen.litLength;
	matchLengthSum += seqLen.matchLength;
	sp++;
	}
	assert(litLengthSum <= litSize);
	if (!lastSequence) {
	assert(litLengthSum == litSize);
	}
	return matchLengthSum + litSize;
	}

	/** ZSTD_compressSubBlock_sequences() :
	* Compresses sequences section for a sub-block.
	* fseMetadata->llType, fseMetadata->ofType, and fseMetadata->mlType have
	* symbol compression modes for the super-block.
	* The first successfully compressed block will have these in its header.
	* We set entropyWritten=1 when we succeed in compressing the sequences.
	* The following sub-blocks will always have repeat mode.
	* @return : compressed size of sequences section of a sub-block
	* Or 0 if it is unable to compress
	* Or error code. */
	static size_t ZSTD_compressSubBlock_sequences(const ZSTD_fseCTables_t* fseTables,
	const ZSTD_fseCTablesMetadata_t* fseMetadata,
	const seqDef* sequences, size_t nbSeq,
	const BYTE* llCode, const BYTE* mlCode, const BYTE* ofCode,
	const ZSTD_CCtx_params* cctxParams,
	void* dst, size_t dstCapacity,
	const int bmi2, int writeEntropy, int* entropyWritten)
	{
	const int longOffsets = cctxParams->cParams.windowLog > STREAM_ACCUMULATOR_MIN;
	BYTE* const ostart = (BYTE*)dst;
	BYTE* const oend = ostart + dstCapacity;
	BYTE* op = ostart;
	BYTE* seqHead;

	DEBUGLOG(5, "ZSTD_compressSubBlock_sequences (nbSeq=%zu, writeEntropy=%d, longOffsets=%d)", nbSeq, writeEntropy, longOffsets);

	*entropyWritten = 0;
	/* Sequences Header */
	RETURN_ERROR_IF((oend-op) < 3 /max nbSeq Size/ + 1 /seqHead/,
	dstSize_tooSmall, "");
	if (nbSeq < 0x7F)
	*op++ = (BYTE)nbSeq;
	else if (nbSeq < LONGNBSEQ)
	op[0] = (BYTE)((nbSeq>>8) + 0x80), op[1] = (BYTE)nbSeq, op+=2;
	else
	op[0]=0xFF, MEM_writeLE16(op+1, (U16)(nbSeq - LONGNBSEQ)), op+=3;
	if (nbSeq==0) {
	return op - ostart;
	}

	/* seqHead : flags for FSE encoding type */
	seqHead = op++;

	DEBUGLOG(5, "ZSTD_compressSubBlock_sequences (seqHeadSize=%u)", (unsigned)(op-ostart));

	if (writeEntropy) {
	const U32 LLtype = fseMetadata->llType;
	const U32 Offtype = fseMetadata->ofType;
	const U32 MLtype = fseMetadata->mlType;
	DEBUGLOG(5, "ZSTD_compressSubBlock_sequences (fseTablesSize=%zu)", fseMetadata->fseTablesSize);
	*seqHead = (BYTE)((LLtype<<6) + (Offtype<<4) + (MLtype<<2));
	memcpy(op, fseMetadata->fseTablesBuffer, fseMetadata->fseTablesSize);
	op += fseMetadata->fseTablesSize;
	} else {
	const U32 repeat = set_repeat;
	*seqHead = (BYTE)((repeat<<6) + (repeat<<4) + (repeat<<2));
	}

	{ size_t const bitstreamSize = ZSTD_encodeSequences(
	op, oend - op,
	fseTables->matchlengthCTable, mlCode,
	fseTables->offcodeCTable, ofCode,
	fseTables->litlengthCTable, llCode,
	sequences, nbSeq,
	longOffsets, bmi2);
	FORWARD_IF_ERROR(bitstreamSize, "ZSTD_encodeSequences failed");
	op += bitstreamSize;
	/* zstd versions <= 1.3.4 mistakenly report corruption when
	* FSE_readNCount() receives a buffer < 4 bytes.
	* Fixed by https://github.com/facebook/zstd/pull/1146.
	* This can happen when the last set_compressed table present is 2
	* bytes and the bitstream is only one byte.
	* In this exceedingly rare case, we will simply emit an uncompressed
	* block, since it isn't worth optimizing.
	*/
	#ifndef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
	if (writeEntropy && fseMetadata->lastCountSize && fseMetadata->lastCountSize + bitstreamSize < 4) {
	/* NCountSize >= 2 && bitstreamSize > 0 ==> lastCountSize == 3 */
	assert(fseMetadata->lastCountSize + bitstreamSize == 3);
	DEBUGLOG(5, "Avoiding bug in zstd decoder in versions <= 1.3.4 by "
	"emitting an uncompressed block.");
	return 0;
	}
	#endif
	DEBUGLOG(5, "ZSTD_compressSubBlock_sequences (bitstreamSize=%zu)", bitstreamSize);
	}

	/* zstd versions <= 1.4.0 mistakenly report error when
	* sequences section body size is less than 3 bytes.
	* Fixed by https://github.com/facebook/zstd/pull/1664.
	* This can happen when the previous sequences section block is compressed
	* with rle mode and the current block's sequences section is compressed
	* with repeat mode where sequences section body size can be 1 byte.
	*/
	#ifndef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
	if (op-seqHead < 4) {
	DEBUGLOG(5, "Avoiding bug in zstd decoder in versions <= 1.4.0 by emitting "
	"an uncompressed block when sequences are < 4 bytes");
	return 0;
	}
	#endif

	*entropyWritten = 1;
	return op - ostart;
	}

	/** ZSTD_compressSubBlock() :
	* Compresses a single sub-block.
	* @return : compressed size of the sub-block
	* Or 0 if it failed to compress. */
	static size_t ZSTD_compressSubBlock(const ZSTD_entropyCTables_t* entropy,
	const ZSTD_entropyCTablesMetadata_t* entropyMetadata,
	const seqDef* sequences, size_t nbSeq,
	const BYTE* literals, size_t litSize,
	const BYTE* llCode, const BYTE* mlCode, const BYTE* ofCode,
	const ZSTD_CCtx_params* cctxParams,
	void* dst, size_t dstCapacity,
	const int bmi2,
	int writeLitEntropy, int writeSeqEntropy,
	int* litEntropyWritten, int* seqEntropyWritten,
	U32 lastBlock)
	{
	BYTE* const ostart = (BYTE*)dst;
	BYTE* const oend = ostart + dstCapacity;
	BYTE* op = ostart + ZSTD_blockHeaderSize;
	DEBUGLOG(5, "ZSTD_compressSubBlock (litSize=%zu, nbSeq=%zu, writeLitEntropy=%d, writeSeqEntropy=%d, lastBlock=%d)",
	litSize, nbSeq, writeLitEntropy, writeSeqEntropy, lastBlock);
	{ size_t cLitSize = ZSTD_compressSubBlock_literal((const HUF_CElt*)entropy->huf.CTable,
	&entropyMetadata->hufMetadata, literals, litSize,
	op, oend-op, bmi2, writeLitEntropy, litEntropyWritten);
	FORWARD_IF_ERROR(cLitSize, "ZSTD_compressSubBlock_literal failed");
	if (cLitSize == 0) return 0;
	op += cLitSize;
	}
	{ size_t cSeqSize = ZSTD_compressSubBlock_sequences(&entropy->fse,
	&entropyMetadata->fseMetadata,
	sequences, nbSeq,
	llCode, mlCode, ofCode,
	cctxParams,
	op, oend-op,
	bmi2, writeSeqEntropy, seqEntropyWritten);
	FORWARD_IF_ERROR(cSeqSize, "ZSTD_compressSubBlock_sequences failed");
	if (cSeqSize == 0) return 0;
	op += cSeqSize;
	}
	/* Write block header */
	{ size_t cSize = (op-ostart)-ZSTD_blockHeaderSize;
	U32 const cBlockHeader24 = lastBlock + (((U32)bt_compressed)<<1) + (U32)(cSize << 3);
	MEM_writeLE24(ostart, cBlockHeader24);
	}
	return op-ostart;
	}

	static size_t ZSTD_estimateSubBlockSize_literal(const BYTE* literals, size_t litSize,
	const ZSTD_hufCTables_t* huf,
	const ZSTD_hufCTablesMetadata_t* hufMetadata,
	void* workspace, size_t wkspSize,
	int writeEntropy)
	{
	unsigned* const countWksp = (unsigned*)workspace;
	unsigned maxSymbolValue = 255;
	size_t literalSectionHeaderSize = 3; /* Use hard coded size of 3 bytes */

	if (hufMetadata->hType == set_basic) return litSize;
	else if (hufMetadata->hType == set_rle) return 1;
	else if (hufMetadata->hType == set_compressed \|\| hufMetadata->hType == set_repeat) {
	size_t const largest = HIST_count_wksp (countWksp, &maxSymbolValue, (const BYTE*)literals, litSize, workspace, wkspSize);
	if (ZSTD_isError(largest)) return litSize;
	{ size_t cLitSizeEstimate = HUF_estimateCompressedSize((const HUF_CElt*)huf->CTable, countWksp, maxSymbolValue);
	if (writeEntropy) cLitSizeEstimate += hufMetadata->hufDesSize;
	return cLitSizeEstimate + literalSectionHeaderSize;
	} }
	assert(0); /* impossible */
	return 0;
	}

	static size_t ZSTD_estimateSubBlockSize_symbolType(symbolEncodingType_e type,
	const BYTE* codeTable, unsigned maxCode,
	size_t nbSeq, const FSE_CTable* fseCTable,
	const U32* additionalBits,
	short const* defaultNorm, U32 defaultNormLog,
	void* workspace, size_t wkspSize)
	{
	unsigned* const countWksp = (unsigned*)workspace;
	const BYTE* ctp = codeTable;
	const BYTE* const ctStart = ctp;
	const BYTE* const ctEnd = ctStart + nbSeq;
	size_t cSymbolTypeSizeEstimateInBits = 0;
	unsigned max = maxCode;

	HIST_countFast_wksp(countWksp, &max, codeTable, nbSeq, workspace, wkspSize); /* can't fail */
	if (type == set_basic) {
	cSymbolTypeSizeEstimateInBits = ZSTD_crossEntropyCost(defaultNorm, defaultNormLog, countWksp, max);
	} else if (type == set_rle) {
	cSymbolTypeSizeEstimateInBits = 0;
	} else if (type == set_compressed \|\| type == set_repeat) {
	cSymbolTypeSizeEstimateInBits = ZSTD_fseBitCost(fseCTable, countWksp, max);
	}
	if (ZSTD_isError(cSymbolTypeSizeEstimateInBits)) return nbSeq * 10;
	while (ctp < ctEnd) {
	if (additionalBits) cSymbolTypeSizeEstimateInBits += additionalBits[*ctp];
	else cSymbolTypeSizeEstimateInBits += ctp; / for offset, offset code is also the number of additional bits */
	ctp++;
	}
	return cSymbolTypeSizeEstimateInBits / 8;
	}

	static size_t ZSTD_estimateSubBlockSize_sequences(const BYTE* ofCodeTable,
	const BYTE* llCodeTable,
	const BYTE* mlCodeTable,
	size_t nbSeq,
	const ZSTD_fseCTables_t* fseTables,
	const ZSTD_fseCTablesMetadata_t* fseMetadata,
	void* workspace, size_t wkspSize,
	int writeEntropy)
	{
	size_t sequencesSectionHeaderSize = 3; /* Use hard coded size of 3 bytes */
	size_t cSeqSizeEstimate = 0;
	cSeqSizeEstimate += ZSTD_estimateSubBlockSize_symbolType(fseMetadata->ofType, ofCodeTable, MaxOff,
	nbSeq, fseTables->offcodeCTable, NULL,
	OF_defaultNorm, OF_defaultNormLog,
	workspace, wkspSize);
	cSeqSizeEstimate += ZSTD_estimateSubBlockSize_symbolType(fseMetadata->llType, llCodeTable, MaxLL,
	nbSeq, fseTables->litlengthCTable, LL_bits,
	LL_defaultNorm, LL_defaultNormLog,
	workspace, wkspSize);
	cSeqSizeEstimate += ZSTD_estimateSubBlockSize_symbolType(fseMetadata->mlType, mlCodeTable, MaxML,
	nbSeq, fseTables->matchlengthCTable, ML_bits,
	ML_defaultNorm, ML_defaultNormLog,
	workspace, wkspSize);
	if (writeEntropy) cSeqSizeEstimate += fseMetadata->fseTablesSize;
	return cSeqSizeEstimate + sequencesSectionHeaderSize;
	}

	static size_t ZSTD_estimateSubBlockSize(const BYTE* literals, size_t litSize,
	const BYTE* ofCodeTable,
	const BYTE* llCodeTable,
	const BYTE* mlCodeTable,
	size_t nbSeq,
	const ZSTD_entropyCTables_t* entropy,
	const ZSTD_entropyCTablesMetadata_t* entropyMetadata,
	void* workspace, size_t wkspSize,
	int writeLitEntropy, int writeSeqEntropy) {
	size_t cSizeEstimate = 0;
	cSizeEstimate += ZSTD_estimateSubBlockSize_literal(literals, litSize,
	&entropy->huf, &entropyMetadata->hufMetadata,
	workspace, wkspSize, writeLitEntropy);
	cSizeEstimate += ZSTD_estimateSubBlockSize_sequences(ofCodeTable, llCodeTable, mlCodeTable,
	nbSeq, &entropy->fse, &entropyMetadata->fseMetadata,
	workspace, wkspSize, writeSeqEntropy);
	return cSizeEstimate + ZSTD_blockHeaderSize;
	}

	static int ZSTD_needSequenceEntropyTables(ZSTD_fseCTablesMetadata_t const* fseMetadata)
	{
	if (fseMetadata->llType == set_compressed \|\| fseMetadata->llType == set_rle)
	return 1;
	if (fseMetadata->mlType == set_compressed \|\| fseMetadata->mlType == set_rle)
	return 1;
	if (fseMetadata->ofType == set_compressed \|\| fseMetadata->ofType == set_rle)
	return 1;
	return 0;
	}

	/** ZSTD_compressSubBlock_multi() :
	* Breaks super-block into multiple sub-blocks and compresses them.
	* Entropy will be written to the first block.
	* The following blocks will use repeat mode to compress.
	* All sub-blocks are compressed blocks (no raw or rle blocks).
	* @return : compressed size of the super block (which is multiple ZSTD blocks)
	* Or 0 if it failed to compress. */
	static size_t ZSTD_compressSubBlock_multi(const seqStore_t* seqStorePtr,
	const ZSTD_compressedBlockState_t* prevCBlock,
	ZSTD_compressedBlockState_t* nextCBlock,
	const ZSTD_entropyCTablesMetadata_t* entropyMetadata,
	const ZSTD_CCtx_params* cctxParams,
	void* dst, size_t dstCapacity,
	const void* src, size_t srcSize,
	const int bmi2, U32 lastBlock,
	void* workspace, size_t wkspSize)
	{
	const seqDef* const sstart = seqStorePtr->sequencesStart;
	const seqDef* const send = seqStorePtr->sequences;
	const seqDef* sp = sstart;
	const BYTE* const lstart = seqStorePtr->litStart;
	const BYTE* const lend = seqStorePtr->lit;
	const BYTE* lp = lstart;
	BYTE const* ip = (BYTE const*)src;
	BYTE const* const iend = ip + srcSize;
	BYTE* const ostart = (BYTE*)dst;
	BYTE* const oend = ostart + dstCapacity;
	BYTE* op = ostart;
	const BYTE* llCodePtr = seqStorePtr->llCode;
	const BYTE* mlCodePtr = seqStorePtr->mlCode;
	const BYTE* ofCodePtr = seqStorePtr->ofCode;
	size_t targetCBlockSize = cctxParams->targetCBlockSize;
	size_t litSize, seqCount;
	int writeLitEntropy = entropyMetadata->hufMetadata.hType == set_compressed;
	int writeSeqEntropy = 1;
	int lastSequence = 0;

	DEBUGLOG(5, "ZSTD_compressSubBlock_multi (litSize=%u, nbSeq=%u)",
	(unsigned)(lend-lp), (unsigned)(send-sstart));

	litSize = 0;
	seqCount = 0;
	do {
	size_t cBlockSizeEstimate = 0;
	if (sstart == send) {
	lastSequence = 1;
	} else {
	const seqDef* const sequence = sp + seqCount;
	lastSequence = sequence == send - 1;
	litSize += ZSTD_getSequenceLength(seqStorePtr, sequence).litLength;
	seqCount++;
	}
	if (lastSequence) {
	assert(lp <= lend);
	assert(litSize <= (size_t)(lend - lp));
	litSize = (size_t)(lend - lp);
	}
	/* I think there is an optimization opportunity here.
	* Calling ZSTD_estimateSubBlockSize for every sequence can be wasteful
	* since it recalculates estimate from scratch.
	* For example, it would recount literal distribution and symbol codes everytime.
	*/
	cBlockSizeEstimate = ZSTD_estimateSubBlockSize(lp, litSize, ofCodePtr, llCodePtr, mlCodePtr, seqCount,
	&nextCBlock->entropy, entropyMetadata,
	workspace, wkspSize, writeLitEntropy, writeSeqEntropy);
	if (cBlockSizeEstimate > targetCBlockSize \|\| lastSequence) {
	int litEntropyWritten = 0;
	int seqEntropyWritten = 0;
	const size_t decompressedSize = ZSTD_seqDecompressedSize(seqStorePtr, sp, seqCount, litSize, lastSequence);
	const size_t cSize = ZSTD_compressSubBlock(&nextCBlock->entropy, entropyMetadata,
	sp, seqCount,
	lp, litSize,
	llCodePtr, mlCodePtr, ofCodePtr,
	cctxParams,
	op, oend-op,
	bmi2, writeLitEntropy, writeSeqEntropy,
	&litEntropyWritten, &seqEntropyWritten,
	lastBlock && lastSequence);
	FORWARD_IF_ERROR(cSize, "ZSTD_compressSubBlock failed");
	if (cSize > 0 && cSize < decompressedSize) {
	DEBUGLOG(5, "Committed the sub-block");
	assert(ip + decompressedSize <= iend);
	ip += decompressedSize;
	sp += seqCount;
	lp += litSize;
	op += cSize;
	llCodePtr += seqCount;
	mlCodePtr += seqCount;
	ofCodePtr += seqCount;
	litSize = 0;
	seqCount = 0;
	/* Entropy only needs to be written once */
	if (litEntropyWritten) {
	writeLitEntropy = 0;
	}
	if (seqEntropyWritten) {
	writeSeqEntropy = 0;
	}
	}
	}
	} while (!lastSequence);
	if (writeLitEntropy) {
	DEBUGLOG(5, "ZSTD_compressSubBlock_multi has literal entropy tables unwritten");
	memcpy(&nextCBlock->entropy.huf, &prevCBlock->entropy.huf, sizeof(prevCBlock->entropy.huf));
	}
	if (writeSeqEntropy && ZSTD_needSequenceEntropyTables(&entropyMetadata->fseMetadata)) {
	/* If we haven't written our entropy tables, then we've violated our contract and
	* must emit an uncompressed block.
	*/
	DEBUGLOG(5, "ZSTD_compressSubBlock_multi has sequence entropy tables unwritten");
	return 0;
	}
	if (ip < iend) {
	size_t const cSize = ZSTD_noCompressBlock(op, oend - op, ip, iend - ip, lastBlock);
	DEBUGLOG(5, "ZSTD_compressSubBlock_multi last sub-block uncompressed, %zu bytes", (size_t)(iend - ip));
	FORWARD_IF_ERROR(cSize, "ZSTD_noCompressBlock failed");
	assert(cSize != 0);
	op += cSize;
	/* We have to regenerate the repcodes because we've skipped some sequences */
	if (sp < send) {
	seqDef const* seq;
	repcodes_t rep;
	memcpy(&rep, prevCBlock->rep, sizeof(rep));
	for (seq = sstart; seq < sp; ++seq) {
	rep = ZSTD_updateRep(rep.rep, seq->offset - 1, ZSTD_getSequenceLength(seqStorePtr, seq).litLength == 0);
	}
	memcpy(nextCBlock->rep, &rep, sizeof(rep));
	}
	}
	DEBUGLOG(5, "ZSTD_compressSubBlock_multi compressed");
	return op-ostart;
	}

	size_t ZSTD_compressSuperBlock(ZSTD_CCtx* zc,
	void* dst, size_t dstCapacity,
	void const* src, size_t srcSize,
	unsigned lastBlock) {
	ZSTD_entropyCTablesMetadata_t entropyMetadata;

	FORWARD_IF_ERROR(ZSTD_buildSuperBlockEntropy(&zc->seqStore,
	&zc->blockState.prevCBlock->entropy,
	&zc->blockState.nextCBlock->entropy,
	&zc->appliedParams,
	&entropyMetadata,
	zc->entropyWorkspace, HUF_WORKSPACE_SIZE /* statically allocated in resetCCtx */), "");

	return ZSTD_compressSubBlock_multi(&zc->seqStore,
	zc->blockState.prevCBlock,
	zc->blockState.nextCBlock,
	&entropyMetadata,
	&zc->appliedParams,
	dst, dstCapacity,
	src, srcSize,
	zc->bmi2, lastBlock,
	zc->entropyWorkspace, HUF_WORKSPACE_SIZE /* statically allocated in resetCCtx */);
	}
	/** ended inlining compress/zstd_compress_superblock.c **/
	/** start inlining compress/zstd_compress.c **/
	/*
	* Copyright (c) 2016-2020, Yann Collet, Facebook, Inc.
	* All rights reserved.
	*
	* This source code is licensed under both the BSD-style license (found in the
	* LICENSE file in the root directory of this source tree) and the GPLv2 (found
	* in the COPYING file in the root directory of this source tree).
	* You may select, at your option, one of the above-listed licenses.
	*/

	/-************************************
	* Dependencies
	***************************************/
	#include <limits.h> /* INT_MAX */
	#include <string.h> /* memset */
	/** start inlining ../common/cpu.h **/
	/*
	* Copyright (c) 2018-2020, Facebook, Inc.
	* All rights reserved.
	*
	* This source code is licensed under both the BSD-style license (found in the
	* LICENSE file in the root directory of this source tree) and the GPLv2 (found
	* in the COPYING file in the root directory of this source tree).
	* You may select, at your option, one of the above-listed licenses.
	*/

	#ifndef ZSTD_COMMON_CPU_H
	#define ZSTD_COMMON_CPU_H

	/**
	* Implementation taken from folly/CpuId.h
	* https://github.com/facebook/folly/blob/master/folly/CpuId.h
	*/

	#include <string.h>

	/** skipping file: mem.h **/

	#ifdef _MSC_VER
	#include <intrin.h>
	#endif

	typedef struct {
	U32 f1c;
	U32 f1d;
	U32 f7b;
	U32 f7c;
	} ZSTD_cpuid_t;

	MEM_STATIC ZSTD_cpuid_t ZSTD_cpuid(void) {
	U32 f1c = 0;
	U32 f1d = 0;
	U32 f7b = 0;
	U32 f7c = 0;
	#if defined(_MSC_VER) && (defined(_M_X64) \|\| defined(_M_IX86))
	int reg[4];
	__cpuid((int*)reg, 0);
	{
	int const n = reg[0];
	if (n >= 1) {
	__cpuid((int*)reg, 1);
	f1c = (U32)reg[2];
	f1d = (U32)reg[3];
	}
	if (n >= 7) {
	__cpuidex((int*)reg, 7, 0);
	f7b = (U32)reg[1];
	f7c = (U32)reg[2];
	}
	}
	#elif defined(__i386__) && defined(__PIC__) && !defined(__clang__) && defined(__GNUC__)
	/* The following block like the normal cpuid branch below, but gcc
	* reserves ebx for use of its pic register so we must specially
	* handle the save and restore to avoid clobbering the register
	*/
	U32 n;
	__asm__(
	"pushl %%ebx\n\t"
	"cpuid\n\t"
	"popl %%ebx\n\t"
	: "=a"(n)
	: "a"(0)
	: "ecx", "edx");
	if (n >= 1) {
	U32 f1a;
	__asm__(
	"pushl %%ebx\n\t"
	"cpuid\n\t"
	"popl %%ebx\n\t"
	: "=a"(f1a), "=c"(f1c), "=d"(f1d)
	: "a"(1));
	}
	if (n >= 7) {
	__asm__(
	"pushl %%ebx\n\t"
	"cpuid\n\t"
	"movl %%ebx, %%eax\n\t"
	"popl %%ebx"
	: "=a"(f7b), "=c"(f7c)
	: "a"(7), "c"(0)
	: "edx");
	}
	#elif defined(__x86_64__) \|\| defined(_M_X64) \|\| defined(__i386__)
	U32 n;
	__asm__("cpuid" : "=a"(n) : "a"(0) : "ebx", "ecx", "edx");
	if (n >= 1) {
	U32 f1a;
	__asm__("cpuid" : "=a"(f1a), "=c"(f1c), "=d"(f1d) : "a"(1) : "ebx");
	}
	if (n >= 7) {
	U32 f7a;
	__asm__("cpuid"
	: "=a"(f7a), "=b"(f7b), "=c"(f7c)
	: "a"(7), "c"(0)
	: "edx");
	}
	#endif
	{
	ZSTD_cpuid_t cpuid;
	cpuid.f1c = f1c;
	cpuid.f1d = f1d;
	cpuid.f7b = f7b;
	cpuid.f7c = f7c;
	return cpuid;
	}
	}

	#define X(name, r, bit) \
	MEM_STATIC int ZSTD_cpuid_##name(ZSTD_cpuid_t const cpuid) { \
	return ((cpuid.r) & (1U << bit)) != 0; \
	}

	/* cpuid(1): Processor Info and Feature Bits. */
	#define C(name, bit) X(name, f1c, bit)
	C(sse3, 0)
	C(pclmuldq, 1)
	C(dtes64, 2)
	C(monitor, 3)
	C(dscpl, 4)
	C(vmx, 5)
	C(smx, 6)
	C(eist, 7)
	C(tm2, 8)
	C(ssse3, 9)
	C(cnxtid, 10)
	C(fma, 12)
	C(cx16, 13)
	C(xtpr, 14)
	C(pdcm, 15)
	C(pcid, 17)
	C(dca, 18)
	C(sse41, 19)
	C(sse42, 20)
	C(x2apic, 21)
	C(movbe, 22)
	C(popcnt, 23)
	C(tscdeadline, 24)
	C(aes, 25)
	C(xsave, 26)
	C(osxsave, 27)
	C(avx, 28)
	C(f16c, 29)
	C(rdrand, 30)
	#undef C
	#define D(name, bit) X(name, f1d, bit)
	D(fpu, 0)
	D(vme, 1)
	D(de, 2)
	D(pse, 3)
	D(tsc, 4)
	D(msr, 5)
	D(pae, 6)
	D(mce, 7)
	D(cx8, 8)
	D(apic, 9)
	D(sep, 11)
	D(mtrr, 12)
	D(pge, 13)
	D(mca, 14)
	D(cmov, 15)
	D(pat, 16)
	D(pse36, 17)
	D(psn, 18)
	D(clfsh, 19)
	D(ds, 21)
	D(acpi, 22)
	D(mmx, 23)
	D(fxsr, 24)
	D(sse, 25)
	D(sse2, 26)
	D(ss, 27)
	D(htt, 28)
	D(tm, 29)
	D(pbe, 31)
	#undef D

	/* cpuid(7): Extended Features. */
	#define B(name, bit) X(name, f7b, bit)
	B(bmi1, 3)
	B(hle, 4)
	B(avx2, 5)
	B(smep, 7)
	B(bmi2, 8)
	B(erms, 9)
	B(invpcid, 10)
	B(rtm, 11)
	B(mpx, 14)
	B(avx512f, 16)
	B(avx512dq, 17)
	B(rdseed, 18)
	B(adx, 19)
	B(smap, 20)
	B(avx512ifma, 21)
	B(pcommit, 22)
	B(clflushopt, 23)
	B(clwb, 24)
	B(avx512pf, 26)
	B(avx512er, 27)
	B(avx512cd, 28)
	B(sha, 29)
	B(avx512bw, 30)
	B(avx512vl, 31)
	#undef B
	#define C(name, bit) X(name, f7c, bit)
	C(prefetchwt1, 0)
	C(avx512vbmi, 1)
	#undef C

	#undef X

	#endif /* ZSTD_COMMON_CPU_H */
	/** ended inlining ../common/cpu.h **/
	/** skipping file: ../common/mem.h **/
	/** skipping file: hist.h **/
	#define FSE_STATIC_LINKING_ONLY /* FSE_encodeSymbol */
	/** skipping file: ../common/fse.h **/
	#define HUF_STATIC_LINKING_ONLY
	/** skipping file: ../common/huf.h **/
	/** skipping file: zstd_compress_internal.h **/
	/** skipping file: zstd_compress_sequences.h **/
	/** skipping file: zstd_compress_literals.h **/
	/** start inlining zstd_fast.h **/
	/*
	* Copyright (c) 2016-2020, Yann Collet, Facebook, Inc.
	* All rights reserved.
	*
	* This source code is licensed under both the BSD-style license (found in the
	* LICENSE file in the root directory of this source tree) and the GPLv2 (found
	* in the COPYING file in the root directory of this source tree).
	* You may select, at your option, one of the above-listed licenses.
	*/

	#ifndef ZSTD_FAST_H
	#define ZSTD_FAST_H

	#if defined (__cplusplus)
	extern "C" {
	#endif

	/** skipping file: ../common/mem.h **/
	/** skipping file: zstd_compress_internal.h **/

	void ZSTD_fillHashTable(ZSTD_matchState_t* ms,
	void const* end, ZSTD_dictTableLoadMethod_e dtlm);
	size_t ZSTD_compressBlock_fast(
	ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
	void const* src, size_t srcSize);
	size_t ZSTD_compressBlock_fast_dictMatchState(
	ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
	void const* src, size_t srcSize);
	size_t ZSTD_compressBlock_fast_extDict(
	ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
	void const* src, size_t srcSize);

	#if defined (__cplusplus)
	}
	#endif

	#endif /* ZSTD_FAST_H */
	/** ended inlining zstd_fast.h **/
	/** start inlining zstd_double_fast.h **/
	/*
	* Copyright (c) 2016-2020, Yann Collet, Facebook, Inc.
	* All rights reserved.
	*
	* This source code is licensed under both the BSD-style license (found in the
	* LICENSE file in the root directory of this source tree) and the GPLv2 (found
	* in the COPYING file in the root directory of this source tree).
	* You may select, at your option, one of the above-listed licenses.
	*/

	#ifndef ZSTD_DOUBLE_FAST_H
	#define ZSTD_DOUBLE_FAST_H

	#if defined (__cplusplus)
	extern "C" {
	#endif

	/** skipping file: ../common/mem.h **/
	/** skipping file: zstd_compress_internal.h **/

	void ZSTD_fillDoubleHashTable(ZSTD_matchState_t* ms,
	void const* end, ZSTD_dictTableLoadMethod_e dtlm);
	size_t ZSTD_compressBlock_doubleFast(
	ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
	void const* src, size_t srcSize);
	size_t ZSTD_compressBlock_doubleFast_dictMatchState(
	ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
	void const* src, size_t srcSize);
	size_t ZSTD_compressBlock_doubleFast_extDict(
	ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
	void const* src, size_t srcSize);


	#if defined (__cplusplus)
	}
	#endif

	#endif /* ZSTD_DOUBLE_FAST_H */
	/** ended inlining zstd_double_fast.h **/
	/** start inlining zstd_lazy.h **/
	/*
	* Copyright (c) 2016-2020, Yann Collet, Facebook, Inc.
	* All rights reserved.
	*
	* This source code is licensed under both the BSD-style license (found in the
	* LICENSE file in the root directory of this source tree) and the GPLv2 (found
	* in the COPYING file in the root directory of this source tree).
	* You may select, at your option, one of the above-listed licenses.
	*/

	#ifndef ZSTD_LAZY_H
	#define ZSTD_LAZY_H

	#if defined (__cplusplus)
	extern "C" {
	#endif

	/** skipping file: zstd_compress_internal.h **/

	U32 ZSTD_insertAndFindFirstIndex(ZSTD_matchState_t* ms, const BYTE* ip);

	void ZSTD_preserveUnsortedMark (U32* const table, U32 const size, U32 const reducerValue); /! used in ZSTD_reduceIndex(). preemptively increase value of ZSTD_DUBT_UNSORTED_MARK /

	size_t ZSTD_compressBlock_btlazy2(
	ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
	void const* src, size_t srcSize);
	size_t ZSTD_compressBlock_lazy2(
	ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
	void const* src, size_t srcSize);
	size_t ZSTD_compressBlock_lazy(
	ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
	void const* src, size_t srcSize);
	size_t ZSTD_compressBlock_greedy(
	ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
	void const* src, size_t srcSize);

	size_t ZSTD_compressBlock_btlazy2_dictMatchState(
	ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
	void const* src, size_t srcSize);
	size_t ZSTD_compressBlock_lazy2_dictMatchState(
	ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
	void const* src, size_t srcSize);
	size_t ZSTD_compressBlock_lazy_dictMatchState(
	ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
	void const* src, size_t srcSize);
	size_t ZSTD_compressBlock_greedy_dictMatchState(
	ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
	void const* src, size_t srcSize);

	size_t ZSTD_compressBlock_greedy_extDict(
	ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
	void const* src, size_t srcSize);
	size_t ZSTD_compressBlock_lazy_extDict(
	ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
	void const* src, size_t srcSize);
	size_t ZSTD_compressBlock_lazy2_extDict(
	ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
	void const* src, size_t srcSize);
	size_t ZSTD_compressBlock_btlazy2_extDict(
	ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
	void const* src, size_t srcSize);

	#if defined (__cplusplus)
	}
	#endif

	#endif /* ZSTD_LAZY_H */
	/** ended inlining zstd_lazy.h **/
	/** start inlining zstd_opt.h **/
	/*
	* Copyright (c) 2016-2020, Yann Collet, Facebook, Inc.
	* All rights reserved.
	*
	* This source code is licensed under both the BSD-style license (found in the
	* LICENSE file in the root directory of this source tree) and the GPLv2 (found
	* in the COPYING file in the root directory of this source tree).
	* You may select, at your option, one of the above-listed licenses.
	*/

	#ifndef ZSTD_OPT_H
	#define ZSTD_OPT_H

	#if defined (__cplusplus)
	extern "C" {
	#endif

	/** skipping file: zstd_compress_internal.h **/

	/* used in ZSTD_loadDictionaryContent() */
	void ZSTD_updateTree(ZSTD_matchState_t* ms, const BYTE* ip, const BYTE* iend);

	size_t ZSTD_compressBlock_btopt(
	ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
	void const* src, size_t srcSize);
	size_t ZSTD_compressBlock_btultra(
	ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
	void const* src, size_t srcSize);
	size_t ZSTD_compressBlock_btultra2(
	ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
	void const* src, size_t srcSize);


	size_t ZSTD_compressBlock_btopt_dictMatchState(
	ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
	void const* src, size_t srcSize);
	size_t ZSTD_compressBlock_btultra_dictMatchState(
	ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
	void const* src, size_t srcSize);

	size_t ZSTD_compressBlock_btopt_extDict(
	ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
	void const* src, size_t srcSize);
	size_t ZSTD_compressBlock_btultra_extDict(
	ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
	void const* src, size_t srcSize);

	/* note : no btultra2 variant for extDict nor dictMatchState,
	* because btultra2 is not meant to work with dictionaries
	* and is only specific for the first block (no prefix) */

	#if defined (__cplusplus)
	}
	#endif

	#endif /* ZSTD_OPT_H */
	/** ended inlining zstd_opt.h **/
	/** start inlining zstd_ldm.h **/
	/*
	* Copyright (c) 2016-2020, Yann Collet, Facebook, Inc.
	* All rights reserved.
	*
	* This source code is licensed under both the BSD-style license (found in the
	* LICENSE file in the root directory of this source tree) and the GPLv2 (found
	* in the COPYING file in the root directory of this source tree).
	* You may select, at your option, one of the above-listed licenses.
	*/

	#ifndef ZSTD_LDM_H
	#define ZSTD_LDM_H

	#if defined (__cplusplus)
	extern "C" {
	#endif

	/** skipping file: zstd_compress_internal.h **/
	/** skipping file: ../zstd.h **/

	/-************************************
	* Long distance matching
	***************************************/

	#define ZSTD_LDM_DEFAULT_WINDOW_LOG ZSTD_WINDOWLOG_LIMIT_DEFAULT

	void ZSTD_ldm_fillHashTable(
	ldmState_t* state, const BYTE* ip,
	const BYTE* iend, ldmParams_t const* params);

	/**
	* ZSTD_ldm_generateSequences():
	*
	* Generates the sequences using the long distance match finder.
	* Generates long range matching sequences in `sequences`, which parse a prefix
	* of the source. `sequences` must be large enough to store every sequence,
	* which can be checked with `ZSTD_ldm_getMaxNbSeq()`.
	* @returns 0 or an error code.
	*
	* NOTE: The user must have called ZSTD_window_update() for all of the input
	* they have, even if they pass it to ZSTD_ldm_generateSequences() in chunks.
	* NOTE: This function returns an error if it runs out of space to store
	* sequences.
	*/
	size_t ZSTD_ldm_generateSequences(
	ldmState_t* ldms, rawSeqStore_t* sequences,
	ldmParams_t const* params, void const* src, size_t srcSize);

	/**
	* ZSTD_ldm_blockCompress():
	*
	* Compresses a block using the predefined sequences, along with a secondary
	* block compressor. The literals section of every sequence is passed to the
	* secondary block compressor, and those sequences are interspersed with the
	* predefined sequences. Returns the length of the last literals.
	* Updates `rawSeqStore.pos` to indicate how many sequences have been consumed.
	* `rawSeqStore.seq` may also be updated to split the last sequence between two
	* blocks.
	* @return The length of the last literals.
	*
	* NOTE: The source must be at most the maximum block size, but the predefined
	* sequences can be any size, and may be longer than the block. In the case that
	* they are longer than the block, the last sequences may need to be split into
	* two. We handle that case correctly, and update `rawSeqStore` appropriately.
	* NOTE: This function does not return any errors.
	*/
	size_t ZSTD_ldm_blockCompress(rawSeqStore_t* rawSeqStore,
	ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
	void const* src, size_t srcSize);

	/**
	* ZSTD_ldm_skipSequences():
	*
	* Skip past `srcSize` bytes worth of sequences in `rawSeqStore`.
	* Avoids emitting matches less than `minMatch` bytes.
	* Must be called for data with is not passed to ZSTD_ldm_blockCompress().
	*/
	void ZSTD_ldm_skipSequences(rawSeqStore_t* rawSeqStore, size_t srcSize,
	U32 const minMatch);


	/** ZSTD_ldm_getTableSize() :
	* Estimate the space needed for long distance matching tables or 0 if LDM is
	* disabled.
	*/
	size_t ZSTD_ldm_getTableSize(ldmParams_t params);

	/** ZSTD_ldm_getSeqSpace() :
	* Return an upper bound on the number of sequences that can be produced by
	* the long distance matcher, or 0 if LDM is disabled.
	*/
	size_t ZSTD_ldm_getMaxNbSeq(ldmParams_t params, size_t maxChunkSize);

	/** ZSTD_ldm_adjustParameters() :
	* If the params->hashRateLog is not set, set it to its default value based on
	* windowLog and params->hashLog.
	*
	* Ensures that params->bucketSizeLog is <= params->hashLog (setting it to
	* params->hashLog if it is not).
	*
	* Ensures that the minMatchLength >= targetLength during optimal parsing.
	*/
	void ZSTD_ldm_adjustParameters(ldmParams_t* params,
	ZSTD_compressionParameters const* cParams);

	#if defined (__cplusplus)
	}
	#endif

	#endif /* ZSTD_FAST_H */
	/** ended inlining zstd_ldm.h **/
	/** skipping file: zstd_compress_superblock.h **/


	/-************************************
	* Helper functions
	***************************************/
	/* ZSTD_compressBound()
	* Note that the result from this function is only compatible with the "normal"
	* full-block strategy.
	* When there are a lot of small blocks due to frequent flush in streaming mode
	* the overhead of headers can make the compressed data to be larger than the
	* return value of ZSTD_compressBound().
	*/
	size_t ZSTD_compressBound(size_t srcSize) {
	return ZSTD_COMPRESSBOUND(srcSize);
	}


	/-************************************
	* Context memory management
	***************************************/
	struct ZSTD_CDict_s {
	const void* dictContent;
	size_t dictContentSize;
	U32* entropyWorkspace; /* entropy workspace of HUF_WORKSPACE_SIZE bytes */
	ZSTD_cwksp workspace;
	ZSTD_matchState_t matchState;
	ZSTD_compressedBlockState_t cBlockState;
	ZSTD_customMem customMem;
	U32 dictID;
	int compressionLevel; /* 0 indicates that advanced API was used to select CDict params */
	}; /* typedef'd to ZSTD_CDict within "zstd.h" */

	ZSTD_CCtx* ZSTD_createCCtx(void)
	{
	return ZSTD_createCCtx_advanced(ZSTD_defaultCMem);
	}

	static void ZSTD_initCCtx(ZSTD_CCtx* cctx, ZSTD_customMem memManager)
	{
	assert(cctx != NULL);
	memset(cctx, 0, sizeof(*cctx));
	cctx->customMem = memManager;
	cctx->bmi2 = ZSTD_cpuid_bmi2(ZSTD_cpuid());
	{ size_t const err = ZSTD_CCtx_reset(cctx, ZSTD_reset_parameters);
	assert(!ZSTD_isError(err));
	(void)err;
	}
	}

	ZSTD_CCtx* ZSTD_createCCtx_advanced(ZSTD_customMem customMem)
	{
	ZSTD_STATIC_ASSERT(zcss_init==0);
	ZSTD_STATIC_ASSERT(ZSTD_CONTENTSIZE_UNKNOWN==(0ULL - 1));
	if (!customMem.customAlloc ^ !customMem.customFree) return NULL;
	{ ZSTD_CCtx* const cctx = (ZSTD_CCtx*)ZSTD_malloc(sizeof(ZSTD_CCtx), customMem);
	if (!cctx) return NULL;
	ZSTD_initCCtx(cctx, customMem);
	return cctx;
	}
	}

	ZSTD_CCtx* ZSTD_initStaticCCtx(void* workspace, size_t workspaceSize)
	{
	ZSTD_cwksp ws;
	ZSTD_CCtx* cctx;
	if (workspaceSize <= sizeof(ZSTD_CCtx)) return NULL; /* minimum size */
	if ((size_t)workspace & 7) return NULL; /* must be 8-aligned */
	ZSTD_cwksp_init(&ws, workspace, workspaceSize);

	cctx = (ZSTD_CCtx*)ZSTD_cwksp_reserve_object(&ws, sizeof(ZSTD_CCtx));
	if (cctx == NULL) return NULL;

	memset(cctx, 0, sizeof(ZSTD_CCtx));
	ZSTD_cwksp_move(&cctx->workspace, &ws);
	cctx->staticSize = workspaceSize;

	/* statically sized space. entropyWorkspace never moves (but prev/next block swap places) */
	if (!ZSTD_cwksp_check_available(&cctx->workspace, HUF_WORKSPACE_SIZE + 2 * sizeof(ZSTD_compressedBlockState_t))) return NULL;
	cctx->blockState.prevCBlock = (ZSTD_compressedBlockState_t*)ZSTD_cwksp_reserve_object(&cctx->workspace, sizeof(ZSTD_compressedBlockState_t));
	cctx->blockState.nextCBlock = (ZSTD_compressedBlockState_t*)ZSTD_cwksp_reserve_object(&cctx->workspace, sizeof(ZSTD_compressedBlockState_t));
	cctx->entropyWorkspace = (U32*)ZSTD_cwksp_reserve_object(&cctx->workspace, HUF_WORKSPACE_SIZE);
	cctx->bmi2 = ZSTD_cpuid_bmi2(ZSTD_cpuid());
	return cctx;
	}

	/**
	* Clears and frees all of the dictionaries in the CCtx.
	*/
	static void ZSTD_clearAllDicts(ZSTD_CCtx* cctx)
	{
	ZSTD_free(cctx->localDict.dictBuffer, cctx->customMem);
	ZSTD_freeCDict(cctx->localDict.cdict);
	memset(&cctx->localDict, 0, sizeof(cctx->localDict));
	memset(&cctx->prefixDict, 0, sizeof(cctx->prefixDict));
	cctx->cdict = NULL;
	}

	static size_t ZSTD_sizeof_localDict(ZSTD_localDict dict)
	{
	size_t const bufferSize = dict.dictBuffer != NULL ? dict.dictSize : 0;
	size_t const cdictSize = ZSTD_sizeof_CDict(dict.cdict);
	return bufferSize + cdictSize;
	}

	static void ZSTD_freeCCtxContent(ZSTD_CCtx* cctx)
	{
	assert(cctx != NULL);
	assert(cctx->staticSize == 0);
	ZSTD_clearAllDicts(cctx);
	#ifdef ZSTD_MULTITHREAD
	ZSTDMT_freeCCtx(cctx->mtctx); cctx->mtctx = NULL;
	#endif
	ZSTD_cwksp_free(&cctx->workspace, cctx->customMem);
	}

	size_t ZSTD_freeCCtx(ZSTD_CCtx* cctx)
	{
	if (cctx==NULL) return 0; /* support free on NULL */
	RETURN_ERROR_IF(cctx->staticSize, memory_allocation,
	"not compatible with static CCtx");
	{
	int cctxInWorkspace = ZSTD_cwksp_owns_buffer(&cctx->workspace, cctx);
	ZSTD_freeCCtxContent(cctx);
	if (!cctxInWorkspace) {
	ZSTD_free(cctx, cctx->customMem);
	}
	}
	return 0;
	}


	static size_t ZSTD_sizeof_mtctx(const ZSTD_CCtx* cctx)
	{
	#ifdef ZSTD_MULTITHREAD
	return ZSTDMT_sizeof_CCtx(cctx->mtctx);
	#else
	(void)cctx;
	return 0;
	#endif
	}


	size_t ZSTD_sizeof_CCtx(const ZSTD_CCtx* cctx)
	{
	if (cctx==NULL) return 0; /* support sizeof on NULL */
	/* cctx may be in the workspace */
	return (cctx->workspace.workspace == cctx ? 0 : sizeof(*cctx))
	+ ZSTD_cwksp_sizeof(&cctx->workspace)
	+ ZSTD_sizeof_localDict(cctx->localDict)
	+ ZSTD_sizeof_mtctx(cctx);
	}

	size_t ZSTD_sizeof_CStream(const ZSTD_CStream* zcs)
	{
	return ZSTD_sizeof_CCtx(zcs); /* same object */
	}

	/* private API call, for dictBuilder only */
	const seqStore_t* ZSTD_getSeqStore(const ZSTD_CCtx* ctx) { return &(ctx->seqStore); }

	static ZSTD_CCtx_params ZSTD_makeCCtxParamsFromCParams(
	ZSTD_compressionParameters cParams)
	{
	ZSTD_CCtx_params cctxParams;
	memset(&cctxParams, 0, sizeof(cctxParams));
	cctxParams.cParams = cParams;
	cctxParams.compressionLevel = ZSTD_CLEVEL_DEFAULT; /* should not matter, as all cParams are presumed properly defined */
	assert(!ZSTD_checkCParams(cParams));
	cctxParams.fParams.contentSizeFlag = 1;
	return cctxParams;
	}

	static ZSTD_CCtx_params* ZSTD_createCCtxParams_advanced(
	ZSTD_customMem customMem)
	{
	ZSTD_CCtx_params* params;
	if (!customMem.customAlloc ^ !customMem.customFree) return NULL;
	params = (ZSTD_CCtx_params*)ZSTD_calloc(
	sizeof(ZSTD_CCtx_params), customMem);
	if (!params) { return NULL; }
	params->customMem = customMem;
	params->compressionLevel = ZSTD_CLEVEL_DEFAULT;
	params->fParams.contentSizeFlag = 1;
	return params;
	}

	ZSTD_CCtx_params* ZSTD_createCCtxParams(void)
	{
	return ZSTD_createCCtxParams_advanced(ZSTD_defaultCMem);
	}

	size_t ZSTD_freeCCtxParams(ZSTD_CCtx_params* params)
	{
	if (params == NULL) { return 0; }
	ZSTD_free(params, params->customMem);
	return 0;
	}

	size_t ZSTD_CCtxParams_reset(ZSTD_CCtx_params* params)
	{
	return ZSTD_CCtxParams_init(params, ZSTD_CLEVEL_DEFAULT);
	}

	size_t ZSTD_CCtxParams_init(ZSTD_CCtx_params* cctxParams, int compressionLevel) {
	RETURN_ERROR_IF(!cctxParams, GENERIC, "NULL pointer!");
	memset(cctxParams, 0, sizeof(*cctxParams));
	cctxParams->compressionLevel = compressionLevel;
	cctxParams->fParams.contentSizeFlag = 1;
	return 0;
	}

	size_t ZSTD_CCtxParams_init_advanced(ZSTD_CCtx_params* cctxParams, ZSTD_parameters params)
	{
	RETURN_ERROR_IF(!cctxParams, GENERIC, "NULL pointer!");
	FORWARD_IF_ERROR( ZSTD_checkCParams(params.cParams) , "");
	memset(cctxParams, 0, sizeof(*cctxParams));
	assert(!ZSTD_checkCParams(params.cParams));
	cctxParams->cParams = params.cParams;
	cctxParams->fParams = params.fParams;
	cctxParams->compressionLevel = ZSTD_CLEVEL_DEFAULT; /* should not matter, as all cParams are presumed properly defined */
	return 0;
	}

	/* ZSTD_assignParamsToCCtxParams() :
	* params is presumed valid at this stage */
	static ZSTD_CCtx_params ZSTD_assignParamsToCCtxParams(
	const ZSTD_CCtx_params* cctxParams, const ZSTD_parameters* params)
	{
	ZSTD_CCtx_params ret = *cctxParams;
	assert(!ZSTD_checkCParams(params->cParams));
	ret.cParams = params->cParams;
	ret.fParams = params->fParams;
	ret.compressionLevel = ZSTD_CLEVEL_DEFAULT; /* should not matter, as all cParams are presumed properly defined */
	return ret;
	}

	ZSTD_bounds ZSTD_cParam_getBounds(ZSTD_cParameter param)
	{
	ZSTD_bounds bounds = { 0, 0, 0 };

	switch(param)
	{
	case ZSTD_c_compressionLevel:
	bounds.lowerBound = ZSTD_minCLevel();
	bounds.upperBound = ZSTD_maxCLevel();
	return bounds;

	case ZSTD_c_windowLog:
	bounds.lowerBound = ZSTD_WINDOWLOG_MIN;
	bounds.upperBound = ZSTD_WINDOWLOG_MAX;
	return bounds;

	case ZSTD_c_hashLog:
	bounds.lowerBound = ZSTD_HASHLOG_MIN;
	bounds.upperBound = ZSTD_HASHLOG_MAX;
	return bounds;

	case ZSTD_c_chainLog:
	bounds.lowerBound = ZSTD_CHAINLOG_MIN;
	bounds.upperBound = ZSTD_CHAINLOG_MAX;
	return bounds;

	case ZSTD_c_searchLog:
	bounds.lowerBound = ZSTD_SEARCHLOG_MIN;
	bounds.upperBound = ZSTD_SEARCHLOG_MAX;
	return bounds;

	case ZSTD_c_minMatch:
	bounds.lowerBound = ZSTD_MINMATCH_MIN;
	bounds.upperBound = ZSTD_MINMATCH_MAX;
	return bounds;

	case ZSTD_c_targetLength:
	bounds.lowerBound = ZSTD_TARGETLENGTH_MIN;
	bounds.upperBound = ZSTD_TARGETLENGTH_MAX;
	return bounds;

	case ZSTD_c_strategy:
	bounds.lowerBound = ZSTD_STRATEGY_MIN;
	bounds.upperBound = ZSTD_STRATEGY_MAX;
	return bounds;

	case ZSTD_c_contentSizeFlag:
	bounds.lowerBound = 0;
	bounds.upperBound = 1;
	return bounds;

	case ZSTD_c_checksumFlag:
	bounds.lowerBound = 0;
	bounds.upperBound = 1;
	return bounds;

	case ZSTD_c_dictIDFlag:
	bounds.lowerBound = 0;
	bounds.upperBound = 1;
	return bounds;

	case ZSTD_c_nbWorkers:
	bounds.lowerBound = 0;
	#ifdef ZSTD_MULTITHREAD
	bounds.upperBound = ZSTDMT_NBWORKERS_MAX;
	#else
	bounds.upperBound = 0;
	#endif
	return bounds;

	case ZSTD_c_jobSize:
	bounds.lowerBound = 0;
	#ifdef ZSTD_MULTITHREAD
	bounds.upperBound = ZSTDMT_JOBSIZE_MAX;
	#else
	bounds.upperBound = 0;
	#endif
	return bounds;

	case ZSTD_c_overlapLog:
	#ifdef ZSTD_MULTITHREAD
	bounds.lowerBound = ZSTD_OVERLAPLOG_MIN;
	bounds.upperBound = ZSTD_OVERLAPLOG_MAX;
	#else
	bounds.lowerBound = 0;
	bounds.upperBound = 0;
	#endif
	return bounds;

	case ZSTD_c_enableLongDistanceMatching:
	bounds.lowerBound = 0;
	bounds.upperBound = 1;
	return bounds;

	case ZSTD_c_ldmHashLog:
	bounds.lowerBound = ZSTD_LDM_HASHLOG_MIN;
	bounds.upperBound = ZSTD_LDM_HASHLOG_MAX;
	return bounds;

	case ZSTD_c_ldmMinMatch:
	bounds.lowerBound = ZSTD_LDM_MINMATCH_MIN;
	bounds.upperBound = ZSTD_LDM_MINMATCH_MAX;
	return bounds;

	case ZSTD_c_ldmBucketSizeLog:
	bounds.lowerBound = ZSTD_LDM_BUCKETSIZELOG_MIN;
	bounds.upperBound = ZSTD_LDM_BUCKETSIZELOG_MAX;
	return bounds;

	case ZSTD_c_ldmHashRateLog:
	bounds.lowerBound = ZSTD_LDM_HASHRATELOG_MIN;
	bounds.upperBound = ZSTD_LDM_HASHRATELOG_MAX;
	return bounds;

	/* experimental parameters */
	case ZSTD_c_rsyncable:
	bounds.lowerBound = 0;
	bounds.upperBound = 1;
	return bounds;

	case ZSTD_c_forceMaxWindow :
	bounds.lowerBound = 0;
	bounds.upperBound = 1;
	return bounds;

	case ZSTD_c_format:
	ZSTD_STATIC_ASSERT(ZSTD_f_zstd1 < ZSTD_f_zstd1_magicless);
	bounds.lowerBound = ZSTD_f_zstd1;
	bounds.upperBound = ZSTD_f_zstd1_magicless; /* note : how to ensure at compile time that this is the highest value enum ? */
	return bounds;

	case ZSTD_c_forceAttachDict:
	ZSTD_STATIC_ASSERT(ZSTD_dictDefaultAttach < ZSTD_dictForceCopy);
	bounds.lowerBound = ZSTD_dictDefaultAttach;
	bounds.upperBound = ZSTD_dictForceLoad; /* note : how to ensure at compile time that this is the highest value enum ? */
	return bounds;

	case ZSTD_c_literalCompressionMode:
	ZSTD_STATIC_ASSERT(ZSTD_lcm_auto < ZSTD_lcm_huffman && ZSTD_lcm_huffman < ZSTD_lcm_uncompressed);
	bounds.lowerBound = ZSTD_lcm_auto;
	bounds.upperBound = ZSTD_lcm_uncompressed;
	return bounds;

	case ZSTD_c_targetCBlockSize:
	bounds.lowerBound = ZSTD_TARGETCBLOCKSIZE_MIN;
	bounds.upperBound = ZSTD_TARGETCBLOCKSIZE_MAX;
	return bounds;

	case ZSTD_c_srcSizeHint:
	bounds.lowerBound = ZSTD_SRCSIZEHINT_MIN;
	bounds.upperBound = ZSTD_SRCSIZEHINT_MAX;
	return bounds;

	default:
	bounds.error = ERROR(parameter_unsupported);
	return bounds;
	}
	}

	/* ZSTD_cParam_clampBounds:
	* Clamps the value into the bounded range.
	*/
	static size_t ZSTD_cParam_clampBounds(ZSTD_cParameter cParam, int* value)
	{
	ZSTD_bounds const bounds = ZSTD_cParam_getBounds(cParam);
	if (ZSTD_isError(bounds.error)) return bounds.error;
	if (value < bounds.lowerBound) value = bounds.lowerBound;
	if (value > bounds.upperBound) value = bounds.upperBound;
	return 0;
	}

	#define BOUNDCHECK(cParam, val) { \
	RETURN_ERROR_IF(!ZSTD_cParam_withinBounds(cParam,val), \
	parameter_outOfBound, "Param out of bounds"); \
	}


	static int ZSTD_isUpdateAuthorized(ZSTD_cParameter param)
	{
	switch(param)
	{
	case ZSTD_c_compressionLevel:
	case ZSTD_c_hashLog:
	case ZSTD_c_chainLog:
	case ZSTD_c_searchLog:
	case ZSTD_c_minMatch:
	case ZSTD_c_targetLength:
	case ZSTD_c_strategy:
	return 1;

	case ZSTD_c_format:
	case ZSTD_c_windowLog:
	case ZSTD_c_contentSizeFlag:
	case ZSTD_c_checksumFlag:
	case ZSTD_c_dictIDFlag:
	case ZSTD_c_forceMaxWindow :
	case ZSTD_c_nbWorkers:
	case ZSTD_c_jobSize:
	case ZSTD_c_overlapLog:
	case ZSTD_c_rsyncable:
	case ZSTD_c_enableLongDistanceMatching:
	case ZSTD_c_ldmHashLog:
	case ZSTD_c_ldmMinMatch:
	case ZSTD_c_ldmBucketSizeLog:
	case ZSTD_c_ldmHashRateLog:
	case ZSTD_c_forceAttachDict:
	case ZSTD_c_literalCompressionMode:
	case ZSTD_c_targetCBlockSize:
	case ZSTD_c_srcSizeHint:
	default:
	return 0;
	}
	}

	size_t ZSTD_CCtx_setParameter(ZSTD_CCtx* cctx, ZSTD_cParameter param, int value)
	{
	DEBUGLOG(4, "ZSTD_CCtx_setParameter (%i, %i)", (int)param, value);
	if (cctx->streamStage != zcss_init) {
	if (ZSTD_isUpdateAuthorized(param)) {
	cctx->cParamsChanged = 1;
	} else {
	RETURN_ERROR(stage_wrong, "can only set params in ctx init stage");
	} }

	switch(param)
	{
	case ZSTD_c_nbWorkers:
	RETURN_ERROR_IF((value!=0) && cctx->staticSize, parameter_unsupported,
	"MT not compatible with static alloc");
	break;

	case ZSTD_c_compressionLevel:
	case ZSTD_c_windowLog:
	case ZSTD_c_hashLog:
	case ZSTD_c_chainLog:
	case ZSTD_c_searchLog:
	case ZSTD_c_minMatch:
	case ZSTD_c_targetLength:
	case ZSTD_c_strategy:
	case ZSTD_c_ldmHashRateLog:
	case ZSTD_c_format:
	case ZSTD_c_contentSizeFlag:
	case ZSTD_c_checksumFlag:
	case ZSTD_c_dictIDFlag:
	case ZSTD_c_forceMaxWindow:
	case ZSTD_c_forceAttachDict:
	case ZSTD_c_literalCompressionMode:
	case ZSTD_c_jobSize:
	case ZSTD_c_overlapLog:
	case ZSTD_c_rsyncable:
	case ZSTD_c_enableLongDistanceMatching:
	case ZSTD_c_ldmHashLog:
	case ZSTD_c_ldmMinMatch:
	case ZSTD_c_ldmBucketSizeLog:
	case ZSTD_c_targetCBlockSize:
	case ZSTD_c_srcSizeHint:
	break;

	default: RETURN_ERROR(parameter_unsupported, "unknown parameter");
	}
	return ZSTD_CCtxParams_setParameter(&cctx->requestedParams, param, value);
	}

	size_t ZSTD_CCtxParams_setParameter(ZSTD_CCtx_params* CCtxParams,
	ZSTD_cParameter param, int value)
	{
	DEBUGLOG(4, "ZSTD_CCtxParams_setParameter (%i, %i)", (int)param, value);
	switch(param)
	{
	case ZSTD_c_format :
	BOUNDCHECK(ZSTD_c_format, value);
	CCtxParams->format = (ZSTD_format_e)value;
	return (size_t)CCtxParams->format;

	case ZSTD_c_compressionLevel : {
	FORWARD_IF_ERROR(ZSTD_cParam_clampBounds(param, &value), "");
	if (value) { /* 0 : does not change current level */
	CCtxParams->compressionLevel = value;
	}
	if (CCtxParams->compressionLevel >= 0) return (size_t)CCtxParams->compressionLevel;
	return 0; /* return type (size_t) cannot represent negative values */
	}

	case ZSTD_c_windowLog :
	if (value!=0) /* 0 => use default */
	BOUNDCHECK(ZSTD_c_windowLog, value);
	CCtxParams->cParams.windowLog = (U32)value;
	return CCtxParams->cParams.windowLog;

	case ZSTD_c_hashLog :
	if (value!=0) /* 0 => use default */
	BOUNDCHECK(ZSTD_c_hashLog, value);
	CCtxParams->cParams.hashLog = (U32)value;
	return CCtxParams->cParams.hashLog;

	case ZSTD_c_chainLog :
	if (value!=0) /* 0 => use default */
	BOUNDCHECK(ZSTD_c_chainLog, value);
	CCtxParams->cParams.chainLog = (U32)value;
	return CCtxParams->cParams.chainLog;

	case ZSTD_c_searchLog :
	if (value!=0) /* 0 => use default */
	BOUNDCHECK(ZSTD_c_searchLog, value);
	CCtxParams->cParams.searchLog = (U32)value;
	return (size_t)value;

	case ZSTD_c_minMatch :
	if (value!=0) /* 0 => use default */
	BOUNDCHECK(ZSTD_c_minMatch, value);
	CCtxParams->cParams.minMatch = value;
	return CCtxParams->cParams.minMatch;

	case ZSTD_c_targetLength :
	BOUNDCHECK(ZSTD_c_targetLength, value);
	CCtxParams->cParams.targetLength = value;
	return CCtxParams->cParams.targetLength;

	case ZSTD_c_strategy :
	if (value!=0) /* 0 => use default */
	BOUNDCHECK(ZSTD_c_strategy, value);
	CCtxParams->cParams.strategy = (ZSTD_strategy)value;
	return (size_t)CCtxParams->cParams.strategy;

	case ZSTD_c_contentSizeFlag :
	/* Content size written in frame header _when known_ (default:1) */
	DEBUGLOG(4, "set content size flag = %u", (value!=0));
	CCtxParams->fParams.contentSizeFlag = value != 0;
	return CCtxParams->fParams.contentSizeFlag;

	case ZSTD_c_checksumFlag :
	/* A 32-bits content checksum will be calculated and written at end of frame (default:0) */
	CCtxParams->fParams.checksumFlag = value != 0;
	return CCtxParams->fParams.checksumFlag;

	case ZSTD_c_dictIDFlag : /* When applicable, dictionary's dictID is provided in frame header (default:1) */
	DEBUGLOG(4, "set dictIDFlag = %u", (value!=0));
	CCtxParams->fParams.noDictIDFlag = !value;
	return !CCtxParams->fParams.noDictIDFlag;

	case ZSTD_c_forceMaxWindow :
	CCtxParams->forceWindow = (value != 0);
	return CCtxParams->forceWindow;

	case ZSTD_c_forceAttachDict : {
	const ZSTD_dictAttachPref_e pref = (ZSTD_dictAttachPref_e)value;
	BOUNDCHECK(ZSTD_c_forceAttachDict, pref);
	CCtxParams->attachDictPref = pref;
	return CCtxParams->attachDictPref;
	}

	case ZSTD_c_literalCompressionMode : {
	const ZSTD_literalCompressionMode_e lcm = (ZSTD_literalCompressionMode_e)value;
	BOUNDCHECK(ZSTD_c_literalCompressionMode, lcm);
	CCtxParams->literalCompressionMode = lcm;
	return CCtxParams->literalCompressionMode;
	}

	case ZSTD_c_nbWorkers :
	#ifndef ZSTD_MULTITHREAD
	RETURN_ERROR_IF(value!=0, parameter_unsupported, "not compiled with multithreading");
	return 0;
	#else
	FORWARD_IF_ERROR(ZSTD_cParam_clampBounds(param, &value), "");
	CCtxParams->nbWorkers = value;
	return CCtxParams->nbWorkers;
	#endif

	case ZSTD_c_jobSize :
	#ifndef ZSTD_MULTITHREAD
	RETURN_ERROR_IF(value!=0, parameter_unsupported, "not compiled with multithreading");
	return 0;
	#else
	/* Adjust to the minimum non-default value. */
	if (value != 0 && value < ZSTDMT_JOBSIZE_MIN)
	value = ZSTDMT_JOBSIZE_MIN;
	FORWARD_IF_ERROR(ZSTD_cParam_clampBounds(param, &value), "");
	assert(value >= 0);
	CCtxParams->jobSize = value;
	return CCtxParams->jobSize;
	#endif

	case ZSTD_c_overlapLog :
	#ifndef ZSTD_MULTITHREAD
	RETURN_ERROR_IF(value!=0, parameter_unsupported, "not compiled with multithreading");
	return 0;
	#else
	FORWARD_IF_ERROR(ZSTD_cParam_clampBounds(ZSTD_c_overlapLog, &value), "");
	CCtxParams->overlapLog = value;
	return CCtxParams->overlapLog;
	#endif

	case ZSTD_c_rsyncable :
	#ifndef ZSTD_MULTITHREAD
	RETURN_ERROR_IF(value!=0, parameter_unsupported, "not compiled with multithreading");
	return 0;
	#else
	FORWARD_IF_ERROR(ZSTD_cParam_clampBounds(ZSTD_c_overlapLog, &value), "");
	CCtxParams->rsyncable = value;
	return CCtxParams->rsyncable;
	#endif

	case ZSTD_c_enableLongDistanceMatching :
	CCtxParams->ldmParams.enableLdm = (value!=0);
	return CCtxParams->ldmParams.enableLdm;

	case ZSTD_c_ldmHashLog :
	if (value!=0) /* 0 ==> auto */
	BOUNDCHECK(ZSTD_c_ldmHashLog, value);
	CCtxParams->ldmParams.hashLog = value;
	return CCtxParams->ldmParams.hashLog;

	case ZSTD_c_ldmMinMatch :
	if (value!=0) /* 0 ==> default */
	BOUNDCHECK(ZSTD_c_ldmMinMatch, value);
	CCtxParams->ldmParams.minMatchLength = value;
	return CCtxParams->ldmParams.minMatchLength;

	case ZSTD_c_ldmBucketSizeLog :
	if (value!=0) /* 0 ==> default */
	BOUNDCHECK(ZSTD_c_ldmBucketSizeLog, value);
	CCtxParams->ldmParams.bucketSizeLog = value;
	return CCtxParams->ldmParams.bucketSizeLog;

	case ZSTD_c_ldmHashRateLog :
	RETURN_ERROR_IF(value > ZSTD_WINDOWLOG_MAX - ZSTD_HASHLOG_MIN,
	parameter_outOfBound, "Param out of bounds!");
	CCtxParams->ldmParams.hashRateLog = value;
	return CCtxParams->ldmParams.hashRateLog;

	case ZSTD_c_targetCBlockSize :
	if (value!=0) /* 0 ==> default */
	BOUNDCHECK(ZSTD_c_targetCBlockSize, value);
	CCtxParams->targetCBlockSize = value;
	return CCtxParams->targetCBlockSize;

	case ZSTD_c_srcSizeHint :
	if (value!=0) /* 0 ==> default */
	BOUNDCHECK(ZSTD_c_srcSizeHint, value);
	CCtxParams->srcSizeHint = value;
	return CCtxParams->srcSizeHint;

	default: RETURN_ERROR(parameter_unsupported, "unknown parameter");
	}
	}

	size_t ZSTD_CCtx_getParameter(ZSTD_CCtx* cctx, ZSTD_cParameter param, int* value)
	{
	return ZSTD_CCtxParams_getParameter(&cctx->requestedParams, param, value);
	}

	size_t ZSTD_CCtxParams_getParameter(
	ZSTD_CCtx_params* CCtxParams, ZSTD_cParameter param, int* value)
	{
	switch(param)
	{
	case ZSTD_c_format :
	*value = CCtxParams->format;
	break;
	case ZSTD_c_compressionLevel :
	*value = CCtxParams->compressionLevel;
	break;
	case ZSTD_c_windowLog :
	*value = (int)CCtxParams->cParams.windowLog;
	break;
	case ZSTD_c_hashLog :
	*value = (int)CCtxParams->cParams.hashLog;
	break;
	case ZSTD_c_chainLog :
	*value = (int)CCtxParams->cParams.chainLog;
	break;
	case ZSTD_c_searchLog :
	*value = CCtxParams->cParams.searchLog;
	break;
	case ZSTD_c_minMatch :
	*value = CCtxParams->cParams.minMatch;
	break;
	case ZSTD_c_targetLength :
	*value = CCtxParams->cParams.targetLength;
	break;
	case ZSTD_c_strategy :
	*value = (unsigned)CCtxParams->cParams.strategy;
	break;
	case ZSTD_c_contentSizeFlag :
	*value = CCtxParams->fParams.contentSizeFlag;
	break;
	case ZSTD_c_checksumFlag :
	*value = CCtxParams->fParams.checksumFlag;
	break;
	case ZSTD_c_dictIDFlag :
	*value = !CCtxParams->fParams.noDictIDFlag;
	break;
	case ZSTD_c_forceMaxWindow :
	*value = CCtxParams->forceWindow;
	break;
	case ZSTD_c_forceAttachDict :
	*value = CCtxParams->attachDictPref;
	break;
	case ZSTD_c_literalCompressionMode :
	*value = CCtxParams->literalCompressionMode;
	break;
	case ZSTD_c_nbWorkers :
	#ifndef ZSTD_MULTITHREAD
	assert(CCtxParams->nbWorkers == 0);
	#endif
	*value = CCtxParams->nbWorkers;
	break;
	case ZSTD_c_jobSize :
	#ifndef ZSTD_MULTITHREAD
	RETURN_ERROR(parameter_unsupported, "not compiled with multithreading");
	#else
	assert(CCtxParams->jobSize <= INT_MAX);
	*value = (int)CCtxParams->jobSize;
	break;
	#endif
	case ZSTD_c_overlapLog :
	#ifndef ZSTD_MULTITHREAD
	RETURN_ERROR(parameter_unsupported, "not compiled with multithreading");
	#else
	*value = CCtxParams->overlapLog;
	break;
	#endif
	case ZSTD_c_rsyncable :
	#ifndef ZSTD_MULTITHREAD
	RETURN_ERROR(parameter_unsupported, "not compiled with multithreading");
	#else
	*value = CCtxParams->rsyncable;
	break;
	#endif
	case ZSTD_c_enableLongDistanceMatching :
	*value = CCtxParams->ldmParams.enableLdm;
	break;
	case ZSTD_c_ldmHashLog :
	*value = CCtxParams->ldmParams.hashLog;
	break;
	case ZSTD_c_ldmMinMatch :
	*value = CCtxParams->ldmParams.minMatchLength;
	break;
	case ZSTD_c_ldmBucketSizeLog :
	*value = CCtxParams->ldmParams.bucketSizeLog;
	break;
	case ZSTD_c_ldmHashRateLog :
	*value = CCtxParams->ldmParams.hashRateLog;
	break;
	case ZSTD_c_targetCBlockSize :
	*value = (int)CCtxParams->targetCBlockSize;
	break;
	case ZSTD_c_srcSizeHint :
	*value = (int)CCtxParams->srcSizeHint;
	break;
	default: RETURN_ERROR(parameter_unsupported, "unknown parameter");
	}
	return 0;
	}

	/** ZSTD_CCtx_setParametersUsingCCtxParams() :
	* just applies `params` into `cctx`
	* no action is performed, parameters are merely stored.
	* If ZSTDMT is enabled, parameters are pushed to cctx->mtctx.
	* This is possible even if a compression is ongoing.
	* In which case, new parameters will be applied on the fly, starting with next compression job.
	*/
	size_t ZSTD_CCtx_setParametersUsingCCtxParams(
	ZSTD_CCtx* cctx, const ZSTD_CCtx_params* params)
	{
	DEBUGLOG(4, "ZSTD_CCtx_setParametersUsingCCtxParams");
	RETURN_ERROR_IF(cctx->streamStage != zcss_init, stage_wrong,
	"The context is in the wrong stage!");
	RETURN_ERROR_IF(cctx->cdict, stage_wrong,
	"Can't override parameters with cdict attached (some must "
	"be inherited from the cdict).");

	cctx->requestedParams = *params;
	return 0;
	}

	ZSTDLIB_API size_t ZSTD_CCtx_setPledgedSrcSize(ZSTD_CCtx* cctx, unsigned long long pledgedSrcSize)
	{
	DEBUGLOG(4, "ZSTD_CCtx_setPledgedSrcSize to %u bytes", (U32)pledgedSrcSize);
	RETURN_ERROR_IF(cctx->streamStage != zcss_init, stage_wrong,
	"Can't set pledgedSrcSize when not in init stage.");
	cctx->pledgedSrcSizePlusOne = pledgedSrcSize+1;
	return 0;
	}

	/**
	* Initializes the local dict using the requested parameters.
	* NOTE: This does not use the pledged src size, because it may be used for more
	* than one compression.
	*/
	static size_t ZSTD_initLocalDict(ZSTD_CCtx* cctx)
	{
	ZSTD_localDict* const dl = &cctx->localDict;
	ZSTD_compressionParameters const cParams = ZSTD_getCParamsFromCCtxParams(
	&cctx->requestedParams, ZSTD_CONTENTSIZE_UNKNOWN, dl->dictSize);
	if (dl->dict == NULL) {
	/* No local dictionary. */
	assert(dl->dictBuffer == NULL);
	assert(dl->cdict == NULL);
	assert(dl->dictSize == 0);
	return 0;
	}
	if (dl->cdict != NULL) {
	assert(cctx->cdict == dl->cdict);
	/* Local dictionary already initialized. */
	return 0;
	}
	assert(dl->dictSize > 0);
	assert(cctx->cdict == NULL);
	assert(cctx->prefixDict.dict == NULL);

	dl->cdict = ZSTD_createCDict_advanced(
	dl->dict,
	dl->dictSize,
	ZSTD_dlm_byRef,
	dl->dictContentType,
	cParams,
	cctx->customMem);
	RETURN_ERROR_IF(!dl->cdict, memory_allocation, "ZSTD_createCDict_advanced failed");
	cctx->cdict = dl->cdict;
	return 0;
	}

	size_t ZSTD_CCtx_loadDictionary_advanced(
	ZSTD_CCtx* cctx, const void* dict, size_t dictSize,
	ZSTD_dictLoadMethod_e dictLoadMethod, ZSTD_dictContentType_e dictContentType)
	{
	RETURN_ERROR_IF(cctx->streamStage != zcss_init, stage_wrong,
	"Can't load a dictionary when ctx is not in init stage.");
	RETURN_ERROR_IF(cctx->staticSize, memory_allocation,
	"no malloc for static CCtx");
	DEBUGLOG(4, "ZSTD_CCtx_loadDictionary_advanced (size: %u)", (U32)dictSize);
	ZSTD_clearAllDicts(cctx); /* in case one already exists */
	if (dict == NULL \|\| dictSize == 0) /* no dictionary mode */
	return 0;
	if (dictLoadMethod == ZSTD_dlm_byRef) {
	cctx->localDict.dict = dict;
	} else {
	void* dictBuffer = ZSTD_malloc(dictSize, cctx->customMem);
	RETURN_ERROR_IF(!dictBuffer, memory_allocation, "NULL pointer!");
	memcpy(dictBuffer, dict, dictSize);
	cctx->localDict.dictBuffer = dictBuffer;
	cctx->localDict.dict = dictBuffer;
	}
	cctx->localDict.dictSize = dictSize;
	cctx->localDict.dictContentType = dictContentType;
	return 0;
	}

	ZSTDLIB_API size_t ZSTD_CCtx_loadDictionary_byReference(
	ZSTD_CCtx* cctx, const void* dict, size_t dictSize)
	{
	return ZSTD_CCtx_loadDictionary_advanced(
	cctx, dict, dictSize, ZSTD_dlm_byRef, ZSTD_dct_auto);
	}

	ZSTDLIB_API size_t ZSTD_CCtx_loadDictionary(ZSTD_CCtx* cctx, const void* dict, size_t dictSize)
	{
	return ZSTD_CCtx_loadDictionary_advanced(
	cctx, dict, dictSize, ZSTD_dlm_byCopy, ZSTD_dct_auto);
	}


	size_t ZSTD_CCtx_refCDict(ZSTD_CCtx* cctx, const ZSTD_CDict* cdict)
	{
	RETURN_ERROR_IF(cctx->streamStage != zcss_init, stage_wrong,
	"Can't ref a dict when ctx not in init stage.");
	/* Free the existing local cdict (if any) to save memory. */
	ZSTD_clearAllDicts(cctx);
	cctx->cdict = cdict;
	return 0;
	}

	size_t ZSTD_CCtx_refPrefix(ZSTD_CCtx* cctx, const void* prefix, size_t prefixSize)
	{
	return ZSTD_CCtx_refPrefix_advanced(cctx, prefix, prefixSize, ZSTD_dct_rawContent);
	}

	size_t ZSTD_CCtx_refPrefix_advanced(
	ZSTD_CCtx* cctx, const void* prefix, size_t prefixSize, ZSTD_dictContentType_e dictContentType)
	{
	RETURN_ERROR_IF(cctx->streamStage != zcss_init, stage_wrong,
	"Can't ref a prefix when ctx not in init stage.");
	ZSTD_clearAllDicts(cctx);
	if (prefix != NULL && prefixSize > 0) {
	cctx->prefixDict.dict = prefix;
	cctx->prefixDict.dictSize = prefixSize;
	cctx->prefixDict.dictContentType = dictContentType;
	}
	return 0;
	}

	/*! ZSTD_CCtx_reset() :
	* Also dumps dictionary */
	size_t ZSTD_CCtx_reset(ZSTD_CCtx* cctx, ZSTD_ResetDirective reset)
	{
	if ( (reset == ZSTD_reset_session_only)
	\|\| (reset == ZSTD_reset_session_and_parameters) ) {
	cctx->streamStage = zcss_init;
	cctx->pledgedSrcSizePlusOne = 0;
	}
	if ( (reset == ZSTD_reset_parameters)
	\|\| (reset == ZSTD_reset_session_and_parameters) ) {
	RETURN_ERROR_IF(cctx->streamStage != zcss_init, stage_wrong,
	"Can't reset parameters only when not in init stage.");
	ZSTD_clearAllDicts(cctx);
	return ZSTD_CCtxParams_reset(&cctx->requestedParams);
	}
	return 0;
	}


	/** ZSTD_checkCParams() :
	control CParam values remain within authorized range.
	@return : 0, or an error code if one value is beyond authorized range */
	size_t ZSTD_checkCParams(ZSTD_compressionParameters cParams)
	{
	BOUNDCHECK(ZSTD_c_windowLog, (int)cParams.windowLog);
	BOUNDCHECK(ZSTD_c_chainLog, (int)cParams.chainLog);
	BOUNDCHECK(ZSTD_c_hashLog, (int)cParams.hashLog);
	BOUNDCHECK(ZSTD_c_searchLog, (int)cParams.searchLog);
	BOUNDCHECK(ZSTD_c_minMatch, (int)cParams.minMatch);
	BOUNDCHECK(ZSTD_c_targetLength,(int)cParams.targetLength);
	BOUNDCHECK(ZSTD_c_strategy, cParams.strategy);
	return 0;
	}

	/** ZSTD_clampCParams() :
	* make CParam values within valid range.
	* @return : valid CParams */
	static ZSTD_compressionParameters
	ZSTD_clampCParams(ZSTD_compressionParameters cParams)
	{
	# define CLAMP_TYPE(cParam, val, type) { \
	ZSTD_bounds const bounds = ZSTD_cParam_getBounds(cParam); \
	if ((int)val<bounds.lowerBound) val=(type)bounds.lowerBound; \
	else if ((int)val>bounds.upperBound) val=(type)bounds.upperBound; \
	}
	# define CLAMP(cParam, val) CLAMP_TYPE(cParam, val, unsigned)
	CLAMP(ZSTD_c_windowLog, cParams.windowLog);
	CLAMP(ZSTD_c_chainLog, cParams.chainLog);
	CLAMP(ZSTD_c_hashLog, cParams.hashLog);
	CLAMP(ZSTD_c_searchLog, cParams.searchLog);
	CLAMP(ZSTD_c_minMatch, cParams.minMatch);
	CLAMP(ZSTD_c_targetLength,cParams.targetLength);
	CLAMP_TYPE(ZSTD_c_strategy,cParams.strategy, ZSTD_strategy);
	return cParams;
	}

	/** ZSTD_cycleLog() :
	* condition for correct operation : hashLog > 1 */
	U32 ZSTD_cycleLog(U32 hashLog, ZSTD_strategy strat)
	{
	U32 const btScale = ((U32)strat >= (U32)ZSTD_btlazy2);
	return hashLog - btScale;
	}

	/** ZSTD_adjustCParams_internal() :
	* optimize `cPar` for a specified input (`srcSize` and `dictSize`).
	* mostly downsize to reduce memory consumption and initialization latency.
	* `srcSize` can be ZSTD_CONTENTSIZE_UNKNOWN when not known.
	* note : `srcSize==0` means 0!
	* condition : cPar is presumed validated (can be checked using ZSTD_checkCParams()). */
	static ZSTD_compressionParameters
	ZSTD_adjustCParams_internal(ZSTD_compressionParameters cPar,
	unsigned long long srcSize,
	size_t dictSize)
	{
	static const U64 minSrcSize = 513; /* (1<<9) + 1 */
	static const U64 maxWindowResize = 1ULL << (ZSTD_WINDOWLOG_MAX-1);
	assert(ZSTD_checkCParams(cPar)==0);

	if (dictSize && srcSize == ZSTD_CONTENTSIZE_UNKNOWN)
	srcSize = minSrcSize;

	/* resize windowLog if input is small enough, to use less memory */
	if ( (srcSize < maxWindowResize)
	&& (dictSize < maxWindowResize) ) {
	U32 const tSize = (U32)(srcSize + dictSize);
	static U32 const hashSizeMin = 1 << ZSTD_HASHLOG_MIN;
	U32 const srcLog = (tSize < hashSizeMin) ? ZSTD_HASHLOG_MIN :
	ZSTD_highbit32(tSize-1) + 1;
	if (cPar.windowLog > srcLog) cPar.windowLog = srcLog;
	}
	if (cPar.hashLog > cPar.windowLog+1) cPar.hashLog = cPar.windowLog+1;
	{ U32 const cycleLog = ZSTD_cycleLog(cPar.chainLog, cPar.strategy);
	if (cycleLog > cPar.windowLog)
	cPar.chainLog -= (cycleLog - cPar.windowLog);
	}

	if (cPar.windowLog < ZSTD_WINDOWLOG_ABSOLUTEMIN)
	cPar.windowLog = ZSTD_WINDOWLOG_ABSOLUTEMIN; /* minimum wlog required for valid frame header */

	return cPar;
	}

	ZSTD_compressionParameters
	ZSTD_adjustCParams(ZSTD_compressionParameters cPar,
	unsigned long long srcSize,
	size_t dictSize)
	{
	cPar = ZSTD_clampCParams(cPar); /* resulting cPar is necessarily valid (all parameters within range) */
	if (srcSize == 0) srcSize = ZSTD_CONTENTSIZE_UNKNOWN;
	return ZSTD_adjustCParams_internal(cPar, srcSize, dictSize);
	}

	static ZSTD_compressionParameters ZSTD_getCParams_internal(int compressionLevel, unsigned long long srcSizeHint, size_t dictSize);
	static ZSTD_parameters ZSTD_getParams_internal(int compressionLevel, unsigned long long srcSizeHint, size_t dictSize);

	ZSTD_compressionParameters ZSTD_getCParamsFromCCtxParams(
	const ZSTD_CCtx_params* CCtxParams, U64 srcSizeHint, size_t dictSize)
	{
	ZSTD_compressionParameters cParams;
	if (srcSizeHint == ZSTD_CONTENTSIZE_UNKNOWN && CCtxParams->srcSizeHint > 0) {
	srcSizeHint = CCtxParams->srcSizeHint;
	}
	cParams = ZSTD_getCParams_internal(CCtxParams->compressionLevel, srcSizeHint, dictSize);
	if (CCtxParams->ldmParams.enableLdm) cParams.windowLog = ZSTD_LDM_DEFAULT_WINDOW_LOG;
	if (CCtxParams->cParams.windowLog) cParams.windowLog = CCtxParams->cParams.windowLog;
	if (CCtxParams->cParams.hashLog) cParams.hashLog = CCtxParams->cParams.hashLog;
	if (CCtxParams->cParams.chainLog) cParams.chainLog = CCtxParams->cParams.chainLog;
	if (CCtxParams->cParams.searchLog) cParams.searchLog = CCtxParams->cParams.searchLog;
	if (CCtxParams->cParams.minMatch) cParams.minMatch = CCtxParams->cParams.minMatch;
	if (CCtxParams->cParams.targetLength) cParams.targetLength = CCtxParams->cParams.targetLength;
	if (CCtxParams->cParams.strategy) cParams.strategy = CCtxParams->cParams.strategy;
	assert(!ZSTD_checkCParams(cParams));
	/* srcSizeHint == 0 means 0 */
	return ZSTD_adjustCParams_internal(cParams, srcSizeHint, dictSize);
	}

	static size_t
	ZSTD_sizeof_matchState(const ZSTD_compressionParameters* const cParams,
	const U32 forCCtx)
	{
	size_t const chainSize = (cParams->strategy == ZSTD_fast) ? 0 : ((size_t)1 << cParams->chainLog);
	size_t const hSize = ((size_t)1) << cParams->hashLog;
	U32 const hashLog3 = (forCCtx && cParams->minMatch==3) ? MIN(ZSTD_HASHLOG3_MAX, cParams->windowLog) : 0;
	size_t const h3Size = hashLog3 ? ((size_t)1) << hashLog3 : 0;
	/* We don't use ZSTD_cwksp_alloc_size() here because the tables aren't
	* surrounded by redzones in ASAN. */
	size_t const tableSpace = chainSize * sizeof(U32)
	+ hSize * sizeof(U32)
	+ h3Size * sizeof(U32);
	size_t const optPotentialSpace =
	ZSTD_cwksp_alloc_size((MaxML+1) * sizeof(U32))
	+ ZSTD_cwksp_alloc_size((MaxLL+1) * sizeof(U32))
	+ ZSTD_cwksp_alloc_size((MaxOff+1) * sizeof(U32))
	+ ZSTD_cwksp_alloc_size((1<<Litbits) * sizeof(U32))
	+ ZSTD_cwksp_alloc_size((ZSTD_OPT_NUM+1) * sizeof(ZSTD_match_t))
	+ ZSTD_cwksp_alloc_size((ZSTD_OPT_NUM+1) * sizeof(ZSTD_optimal_t));
	size_t const optSpace = (forCCtx && (cParams->strategy >= ZSTD_btopt))
	? optPotentialSpace
	: 0;
	DEBUGLOG(4, "chainSize: %u - hSize: %u - h3Size: %u",
	(U32)chainSize, (U32)hSize, (U32)h3Size);
	return tableSpace + optSpace;
	}

	size_t ZSTD_estimateCCtxSize_usingCCtxParams(const ZSTD_CCtx_params* params)
	{
	RETURN_ERROR_IF(params->nbWorkers > 0, GENERIC, "Estimate CCtx size is supported for single-threaded compression only.");
	{ ZSTD_compressionParameters const cParams =
	ZSTD_getCParamsFromCCtxParams(params, ZSTD_CONTENTSIZE_UNKNOWN, 0);
	size_t const blockSize = MIN(ZSTD_BLOCKSIZE_MAX, (size_t)1 << cParams.windowLog);
	U32 const divider = (cParams.minMatch==3) ? 3 : 4;
	size_t const maxNbSeq = blockSize / divider;
	size_t const tokenSpace = ZSTD_cwksp_alloc_size(WILDCOPY_OVERLENGTH + blockSize)
	+ ZSTD_cwksp_alloc_size(maxNbSeq * sizeof(seqDef))
	+ 3 * ZSTD_cwksp_alloc_size(maxNbSeq * sizeof(BYTE));
	size_t const entropySpace = ZSTD_cwksp_alloc_size(HUF_WORKSPACE_SIZE);
	size_t const blockStateSpace = 2 * ZSTD_cwksp_alloc_size(sizeof(ZSTD_compressedBlockState_t));
	size_t const matchStateSize = ZSTD_sizeof_matchState(&cParams, /* forCCtx */ 1);

	size_t const ldmSpace = ZSTD_ldm_getTableSize(params->ldmParams);
	size_t const ldmSeqSpace = ZSTD_cwksp_alloc_size(ZSTD_ldm_getMaxNbSeq(params->ldmParams, blockSize) * sizeof(rawSeq));

	/* estimateCCtxSize is for one-shot compression. So no buffers should
	* be needed. However, we still allocate two 0-sized buffers, which can
	* take space under ASAN. */
	size_t const bufferSpace = ZSTD_cwksp_alloc_size(0)
	+ ZSTD_cwksp_alloc_size(0);

	size_t const cctxSpace = ZSTD_cwksp_alloc_size(sizeof(ZSTD_CCtx));

	size_t const neededSpace =
	cctxSpace +
	entropySpace +
	blockStateSpace +
	ldmSpace +
	ldmSeqSpace +
	matchStateSize +
	tokenSpace +
	bufferSpace;

	DEBUGLOG(5, "estimate workspace : %u", (U32)neededSpace);
	return neededSpace;
	}
	}

	size_t ZSTD_estimateCCtxSize_usingCParams(ZSTD_compressionParameters cParams)
	{
	ZSTD_CCtx_params const params = ZSTD_makeCCtxParamsFromCParams(cParams);
	return ZSTD_estimateCCtxSize_usingCCtxParams(&params);
	}

	static size_t ZSTD_estimateCCtxSize_internal(int compressionLevel)
	{
	ZSTD_compressionParameters const cParams = ZSTD_getCParams_internal(compressionLevel, ZSTD_CONTENTSIZE_UNKNOWN, 0);
	return ZSTD_estimateCCtxSize_usingCParams(cParams);
	}

	size_t ZSTD_estimateCCtxSize(int compressionLevel)
	{
	int level;
	size_t memBudget = 0;
	for (level=MIN(compressionLevel, 1); level<=compressionLevel; level++) {
	size_t const newMB = ZSTD_estimateCCtxSize_internal(level);
	if (newMB > memBudget) memBudget = newMB;
	}
	return memBudget;
	}

	size_t ZSTD_estimateCStreamSize_usingCCtxParams(const ZSTD_CCtx_params* params)
	{
	RETURN_ERROR_IF(params->nbWorkers > 0, GENERIC, "Estimate CCtx size is supported for single-threaded compression only.");
	{ ZSTD_compressionParameters const cParams =
	ZSTD_getCParamsFromCCtxParams(params, ZSTD_CONTENTSIZE_UNKNOWN, 0);
	size_t const CCtxSize = ZSTD_estimateCCtxSize_usingCCtxParams(params);
	size_t const blockSize = MIN(ZSTD_BLOCKSIZE_MAX, (size_t)1 << cParams.windowLog);
	size_t const inBuffSize = ((size_t)1 << cParams.windowLog) + blockSize;
	size_t const outBuffSize = ZSTD_compressBound(blockSize) + 1;
	size_t const streamingSize = ZSTD_cwksp_alloc_size(inBuffSize)
	+ ZSTD_cwksp_alloc_size(outBuffSize);

	return CCtxSize + streamingSize;
	}
	}

	size_t ZSTD_estimateCStreamSize_usingCParams(ZSTD_compressionParameters cParams)
	{
	ZSTD_CCtx_params const params = ZSTD_makeCCtxParamsFromCParams(cParams);
	return ZSTD_estimateCStreamSize_usingCCtxParams(&params);
	}

	static size_t ZSTD_estimateCStreamSize_internal(int compressionLevel)
	{
	ZSTD_compressionParameters const cParams = ZSTD_getCParams_internal(compressionLevel, ZSTD_CONTENTSIZE_UNKNOWN, 0);
	return ZSTD_estimateCStreamSize_usingCParams(cParams);
	}

	size_t ZSTD_estimateCStreamSize(int compressionLevel)
	{
	int level;
	size_t memBudget = 0;
	for (level=MIN(compressionLevel, 1); level<=compressionLevel; level++) {
	size_t const newMB = ZSTD_estimateCStreamSize_internal(level);
	if (newMB > memBudget) memBudget = newMB;
	}
	return memBudget;
	}

	/* ZSTD_getFrameProgression():
	* tells how much data has been consumed (input) and produced (output) for current frame.
	* able to count progression inside worker threads (non-blocking mode).
	*/
	ZSTD_frameProgression ZSTD_getFrameProgression(const ZSTD_CCtx* cctx)
	{
	#ifdef ZSTD_MULTITHREAD
	if (cctx->appliedParams.nbWorkers > 0) {
	return ZSTDMT_getFrameProgression(cctx->mtctx);
	}
	#endif
	{ ZSTD_frameProgression fp;
	size_t const buffered = (cctx->inBuff == NULL) ? 0 :
	cctx->inBuffPos - cctx->inToCompress;
	if (buffered) assert(cctx->inBuffPos >= cctx->inToCompress);
	assert(buffered <= ZSTD_BLOCKSIZE_MAX);
	fp.ingested = cctx->consumedSrcSize + buffered;
	fp.consumed = cctx->consumedSrcSize;
	fp.produced = cctx->producedCSize;
	fp.flushed = cctx->producedCSize; /* simplified; some data might still be left within streaming output buffer */
	fp.currentJobID = 0;
	fp.nbActiveWorkers = 0;
	return fp;
	} }

	/*! ZSTD_toFlushNow()
	* Only useful for multithreading scenarios currently (nbWorkers >= 1).
	*/
	size_t ZSTD_toFlushNow(ZSTD_CCtx* cctx)
	{
	#ifdef ZSTD_MULTITHREAD
	if (cctx->appliedParams.nbWorkers > 0) {
	return ZSTDMT_toFlushNow(cctx->mtctx);
	}
	#endif
	(void)cctx;
	return 0; /* over-simplification; could also check if context is currently running in streaming mode, and in which case, report how many bytes are left to be flushed within output buffer */
	}

	static void ZSTD_assertEqualCParams(ZSTD_compressionParameters cParams1,
	ZSTD_compressionParameters cParams2)
	{
	(void)cParams1;
	(void)cParams2;
	assert(cParams1.windowLog == cParams2.windowLog);
	assert(cParams1.chainLog == cParams2.chainLog);
	assert(cParams1.hashLog == cParams2.hashLog);
	assert(cParams1.searchLog == cParams2.searchLog);
	assert(cParams1.minMatch == cParams2.minMatch);
	assert(cParams1.targetLength == cParams2.targetLength);
	assert(cParams1.strategy == cParams2.strategy);
	}

	void ZSTD_reset_compressedBlockState(ZSTD_compressedBlockState_t* bs)
	{
	int i;
	for (i = 0; i < ZSTD_REP_NUM; ++i)
	bs->rep[i] = repStartValue[i];
	bs->entropy.huf.repeatMode = HUF_repeat_none;
	bs->entropy.fse.offcode_repeatMode = FSE_repeat_none;
	bs->entropy.fse.matchlength_repeatMode = FSE_repeat_none;
	bs->entropy.fse.litlength_repeatMode = FSE_repeat_none;
	}

	/*! ZSTD_invalidateMatchState()
	* Invalidate all the matches in the match finder tables.
	* Requires nextSrc and base to be set (can be NULL).
	*/
	static void ZSTD_invalidateMatchState(ZSTD_matchState_t* ms)
	{
	ZSTD_window_clear(&ms->window);

	ms->nextToUpdate = ms->window.dictLimit;
	ms->loadedDictEnd = 0;
	ms->opt.litLengthSum = 0; /* force reset of btopt stats */
	ms->dictMatchState = NULL;
	}

	/**
	* Indicates whether this compression proceeds directly from user-provided
	* source buffer to user-provided destination buffer (ZSTDb_not_buffered), or
	* whether the context needs to buffer the input/output (ZSTDb_buffered).
	*/
	typedef enum {
	ZSTDb_not_buffered,
	ZSTDb_buffered
	} ZSTD_buffered_policy_e;

	/**
	* Controls, for this matchState reset, whether the tables need to be cleared /
	* prepared for the coming compression (ZSTDcrp_makeClean), or whether the
	* tables can be left unclean (ZSTDcrp_leaveDirty), because we know that a
	* subsequent operation will overwrite the table space anyways (e.g., copying
	* the matchState contents in from a CDict).
	*/
	typedef enum {
	ZSTDcrp_makeClean,
	ZSTDcrp_leaveDirty
	} ZSTD_compResetPolicy_e;

	/**
	* Controls, for this matchState reset, whether indexing can continue where it
	* left off (ZSTDirp_continue), or whether it needs to be restarted from zero
	* (ZSTDirp_reset).
	*/
	typedef enum {
	ZSTDirp_continue,
	ZSTDirp_reset
	} ZSTD_indexResetPolicy_e;

	typedef enum {
	ZSTD_resetTarget_CDict,
	ZSTD_resetTarget_CCtx
	} ZSTD_resetTarget_e;

	static size_t
	ZSTD_reset_matchState(ZSTD_matchState_t* ms,
	ZSTD_cwksp* ws,
	const ZSTD_compressionParameters* cParams,
	const ZSTD_compResetPolicy_e crp,
	const ZSTD_indexResetPolicy_e forceResetIndex,
	const ZSTD_resetTarget_e forWho)
	{
	size_t const chainSize = (cParams->strategy == ZSTD_fast) ? 0 : ((size_t)1 << cParams->chainLog);
	size_t const hSize = ((size_t)1) << cParams->hashLog;
	U32 const hashLog3 = ((forWho == ZSTD_resetTarget_CCtx) && cParams->minMatch==3) ? MIN(ZSTD_HASHLOG3_MAX, cParams->windowLog) : 0;
	size_t const h3Size = hashLog3 ? ((size_t)1) << hashLog3 : 0;

	DEBUGLOG(4, "reset indices : %u", forceResetIndex == ZSTDirp_reset);
	if (forceResetIndex == ZSTDirp_reset) {
	ZSTD_window_init(&ms->window);
	ZSTD_cwksp_mark_tables_dirty(ws);
	}

	ms->hashLog3 = hashLog3;

	ZSTD_invalidateMatchState(ms);

	assert(!ZSTD_cwksp_reserve_failed(ws)); /* check that allocation hasn't already failed */

	ZSTD_cwksp_clear_tables(ws);

	DEBUGLOG(5, "reserving table space");
	/* table Space */
	ms->hashTable = (U32)ZSTD_cwksp_reserve_table(ws, hSize sizeof(U32));
	ms->chainTable = (U32)ZSTD_cwksp_reserve_table(ws, chainSize sizeof(U32));
	ms->hashTable3 = (U32)ZSTD_cwksp_reserve_table(ws, h3Size sizeof(U32));
	RETURN_ERROR_IF(ZSTD_cwksp_reserve_failed(ws), memory_allocation,
	"failed a workspace allocation in ZSTD_reset_matchState");

	DEBUGLOG(4, "reset table : %u", crp!=ZSTDcrp_leaveDirty);
	if (crp!=ZSTDcrp_leaveDirty) {
	/* reset tables only */
	ZSTD_cwksp_clean_tables(ws);
	}

	/* opt parser space */
	if ((forWho == ZSTD_resetTarget_CCtx) && (cParams->strategy >= ZSTD_btopt)) {
	DEBUGLOG(4, "reserving optimal parser space");
	ms->opt.litFreq = (unsigned)ZSTD_cwksp_reserve_aligned(ws, (1<<Litbits) sizeof(unsigned));
	ms->opt.litLengthFreq = (unsigned)ZSTD_cwksp_reserve_aligned(ws, (MaxLL+1) sizeof(unsigned));
	ms->opt.matchLengthFreq = (unsigned)ZSTD_cwksp_reserve_aligned(ws, (MaxML+1) sizeof(unsigned));
	ms->opt.offCodeFreq = (unsigned)ZSTD_cwksp_reserve_aligned(ws, (MaxOff+1) sizeof(unsigned));
	ms->opt.matchTable = (ZSTD_match_t)ZSTD_cwksp_reserve_aligned(ws, (ZSTD_OPT_NUM+1) sizeof(ZSTD_match_t));
	ms->opt.priceTable = (ZSTD_optimal_t)ZSTD_cwksp_reserve_aligned(ws, (ZSTD_OPT_NUM+1) sizeof(ZSTD_optimal_t));
	}

	ms->cParams = *cParams;

	RETURN_ERROR_IF(ZSTD_cwksp_reserve_failed(ws), memory_allocation,
	"failed a workspace allocation in ZSTD_reset_matchState");

	return 0;
	}

	/* ZSTD_indexTooCloseToMax() :
	* minor optimization : prefer memset() rather than reduceIndex()
	* which is measurably slow in some circumstances (reported for Visual Studio).
	* Works when re-using a context for a lot of smallish inputs :
	* if all inputs are smaller than ZSTD_INDEXOVERFLOW_MARGIN,
	* memset() will be triggered before reduceIndex().
	*/
	#define ZSTD_INDEXOVERFLOW_MARGIN (16 MB)
	static int ZSTD_indexTooCloseToMax(ZSTD_window_t w)
	{
	return (size_t)(w.nextSrc - w.base) > (ZSTD_CURRENT_MAX - ZSTD_INDEXOVERFLOW_MARGIN);
	}

	/*! ZSTD_resetCCtx_internal() :
	note : `params` are assumed fully validated at this stage */
	static size_t ZSTD_resetCCtx_internal(ZSTD_CCtx* zc,
	ZSTD_CCtx_params params,
	U64 const pledgedSrcSize,
	ZSTD_compResetPolicy_e const crp,
	ZSTD_buffered_policy_e const zbuff)
	{
	ZSTD_cwksp* const ws = &zc->workspace;
	DEBUGLOG(4, "ZSTD_resetCCtx_internal: pledgedSrcSize=%u, wlog=%u",
	(U32)pledgedSrcSize, params.cParams.windowLog);
	assert(!ZSTD_isError(ZSTD_checkCParams(params.cParams)));

	zc->isFirstBlock = 1;

	if (params.ldmParams.enableLdm) {
	/* Adjust long distance matching parameters */
	ZSTD_ldm_adjustParameters(&params.ldmParams, &params.cParams);
	assert(params.ldmParams.hashLog >= params.ldmParams.bucketSizeLog);
	assert(params.ldmParams.hashRateLog < 32);
	zc->ldmState.hashPower = ZSTD_rollingHash_primePower(params.ldmParams.minMatchLength);
	}

	{ size_t const windowSize = MAX(1, (size_t)MIN(((U64)1 << params.cParams.windowLog), pledgedSrcSize));
	size_t const blockSize = MIN(ZSTD_BLOCKSIZE_MAX, windowSize);
	U32 const divider = (params.cParams.minMatch==3) ? 3 : 4;
	size_t const maxNbSeq = blockSize / divider;
	size_t const tokenSpace = ZSTD_cwksp_alloc_size(WILDCOPY_OVERLENGTH + blockSize)
	+ ZSTD_cwksp_alloc_size(maxNbSeq * sizeof(seqDef))
	+ 3 * ZSTD_cwksp_alloc_size(maxNbSeq * sizeof(BYTE));
	size_t const buffOutSize = (zbuff==ZSTDb_buffered) ? ZSTD_compressBound(blockSize)+1 : 0;
	size_t const buffInSize = (zbuff==ZSTDb_buffered) ? windowSize + blockSize : 0;
	size_t const matchStateSize = ZSTD_sizeof_matchState(&params.cParams, /* forCCtx */ 1);
	size_t const maxNbLdmSeq = ZSTD_ldm_getMaxNbSeq(params.ldmParams, blockSize);

	ZSTD_indexResetPolicy_e needsIndexReset = zc->initialized ? ZSTDirp_continue : ZSTDirp_reset;

	if (ZSTD_indexTooCloseToMax(zc->blockState.matchState.window)) {
	needsIndexReset = ZSTDirp_reset;
	}

	if (!zc->staticSize) ZSTD_cwksp_bump_oversized_duration(ws, 0);

	/* Check if workspace is large enough, alloc a new one if needed */
	{ size_t const cctxSpace = zc->staticSize ? ZSTD_cwksp_alloc_size(sizeof(ZSTD_CCtx)) : 0;
	size_t const entropySpace = ZSTD_cwksp_alloc_size(HUF_WORKSPACE_SIZE);
	size_t const blockStateSpace = 2 * ZSTD_cwksp_alloc_size(sizeof(ZSTD_compressedBlockState_t));
	size_t const bufferSpace = ZSTD_cwksp_alloc_size(buffInSize) + ZSTD_cwksp_alloc_size(buffOutSize);
	size_t const ldmSpace = ZSTD_ldm_getTableSize(params.ldmParams);
	size_t const ldmSeqSpace = ZSTD_cwksp_alloc_size(maxNbLdmSeq * sizeof(rawSeq));

	size_t const neededSpace =
	cctxSpace +
	entropySpace +
	blockStateSpace +
	ldmSpace +
	ldmSeqSpace +
	matchStateSize +
	tokenSpace +
	bufferSpace;

	int const workspaceTooSmall = ZSTD_cwksp_sizeof(ws) < neededSpace;
	int const workspaceWasteful = ZSTD_cwksp_check_wasteful(ws, neededSpace);

	DEBUGLOG(4, "Need %zuKB workspace, including %zuKB for match state, and %zuKB for buffers",
	neededSpace>>10, matchStateSize>>10, bufferSpace>>10);
	DEBUGLOG(4, "windowSize: %zu - blockSize: %zu", windowSize, blockSize);

	if (workspaceTooSmall \|\| workspaceWasteful) {
	DEBUGLOG(4, "Resize workspaceSize from %zuKB to %zuKB",
	ZSTD_cwksp_sizeof(ws) >> 10,
	neededSpace >> 10);

	RETURN_ERROR_IF(zc->staticSize, memory_allocation, "static cctx : no resize");

	needsIndexReset = ZSTDirp_reset;

	ZSTD_cwksp_free(ws, zc->customMem);
	FORWARD_IF_ERROR(ZSTD_cwksp_create(ws, neededSpace, zc->customMem), "");

	DEBUGLOG(5, "reserving object space");
	/* Statically sized space.
	* entropyWorkspace never moves,
	* though prev/next block swap places */
	assert(ZSTD_cwksp_check_available(ws, 2 * sizeof(ZSTD_compressedBlockState_t)));
	zc->blockState.prevCBlock = (ZSTD_compressedBlockState_t*) ZSTD_cwksp_reserve_object(ws, sizeof(ZSTD_compressedBlockState_t));
	RETURN_ERROR_IF(zc->blockState.prevCBlock == NULL, memory_allocation, "couldn't allocate prevCBlock");
	zc->blockState.nextCBlock = (ZSTD_compressedBlockState_t*) ZSTD_cwksp_reserve_object(ws, sizeof(ZSTD_compressedBlockState_t));
	RETURN_ERROR_IF(zc->blockState.nextCBlock == NULL, memory_allocation, "couldn't allocate nextCBlock");
	zc->entropyWorkspace = (U32*) ZSTD_cwksp_reserve_object(ws, HUF_WORKSPACE_SIZE);
	RETURN_ERROR_IF(zc->blockState.nextCBlock == NULL, memory_allocation, "couldn't allocate entropyWorkspace");
	} }

	ZSTD_cwksp_clear(ws);

	/* init params */
	zc->appliedParams = params;
	zc->blockState.matchState.cParams = params.cParams;
	zc->pledgedSrcSizePlusOne = pledgedSrcSize+1;
	zc->consumedSrcSize = 0;
	zc->producedCSize = 0;
	if (pledgedSrcSize == ZSTD_CONTENTSIZE_UNKNOWN)
	zc->appliedParams.fParams.contentSizeFlag = 0;
	DEBUGLOG(4, "pledged content size : %u ; flag : %u",
	(unsigned)pledgedSrcSize, zc->appliedParams.fParams.contentSizeFlag);
	zc->blockSize = blockSize;

	XXH64_reset(&zc->xxhState, 0);
	zc->stage = ZSTDcs_init;
	zc->dictID = 0;

	ZSTD_reset_compressedBlockState(zc->blockState.prevCBlock);

	/* ZSTD_wildcopy() is used to copy into the literals buffer,
	* so we have to oversize the buffer by WILDCOPY_OVERLENGTH bytes.
	*/
	zc->seqStore.litStart = ZSTD_cwksp_reserve_buffer(ws, blockSize + WILDCOPY_OVERLENGTH);
	zc->seqStore.maxNbLit = blockSize;

	/* buffers */
	zc->inBuffSize = buffInSize;
	zc->inBuff = (char*)ZSTD_cwksp_reserve_buffer(ws, buffInSize);
	zc->outBuffSize = buffOutSize;
	zc->outBuff = (char*)ZSTD_cwksp_reserve_buffer(ws, buffOutSize);

	/* ldm bucketOffsets table */
	if (params.ldmParams.enableLdm) {
	/* TODO: avoid memset? */
	size_t const ldmBucketSize =
	((size_t)1) << (params.ldmParams.hashLog -
	params.ldmParams.bucketSizeLog);
	zc->ldmState.bucketOffsets = ZSTD_cwksp_reserve_buffer(ws, ldmBucketSize);
	memset(zc->ldmState.bucketOffsets, 0, ldmBucketSize);
	}

	/* sequences storage */
	ZSTD_referenceExternalSequences(zc, NULL, 0);
	zc->seqStore.maxNbSeq = maxNbSeq;
	zc->seqStore.llCode = ZSTD_cwksp_reserve_buffer(ws, maxNbSeq * sizeof(BYTE));
	zc->seqStore.mlCode = ZSTD_cwksp_reserve_buffer(ws, maxNbSeq * sizeof(BYTE));
	zc->seqStore.ofCode = ZSTD_cwksp_reserve_buffer(ws, maxNbSeq * sizeof(BYTE));
	zc->seqStore.sequencesStart = (seqDef)ZSTD_cwksp_reserve_aligned(ws, maxNbSeq sizeof(seqDef));

	FORWARD_IF_ERROR(ZSTD_reset_matchState(
	&zc->blockState.matchState,
	ws,
	&params.cParams,
	crp,
	needsIndexReset,
	ZSTD_resetTarget_CCtx), "");

	/* ldm hash table */
	if (params.ldmParams.enableLdm) {
	/* TODO: avoid memset? */
	size_t const ldmHSize = ((size_t)1) << params.ldmParams.hashLog;
	zc->ldmState.hashTable = (ldmEntry_t)ZSTD_cwksp_reserve_aligned(ws, ldmHSize sizeof(ldmEntry_t));
	memset(zc->ldmState.hashTable, 0, ldmHSize * sizeof(ldmEntry_t));
	zc->ldmSequences = (rawSeq)ZSTD_cwksp_reserve_aligned(ws, maxNbLdmSeq sizeof(rawSeq));
	zc->maxNbLdmSequences = maxNbLdmSeq;

	ZSTD_window_init(&zc->ldmState.window);
	ZSTD_window_clear(&zc->ldmState.window);
	zc->ldmState.loadedDictEnd = 0;
	}

	DEBUGLOG(3, "wksp: finished allocating, %zd bytes remain available", ZSTD_cwksp_available_space(ws));
	zc->initialized = 1;

	return 0;
	}
	}

	/* ZSTD_invalidateRepCodes() :
	* ensures next compression will not use repcodes from previous block.
	* Note : only works with regular variant;
	* do not use with extDict variant ! */
	void ZSTD_invalidateRepCodes(ZSTD_CCtx* cctx) {
	int i;
	for (i=0; i<ZSTD_REP_NUM; i++) cctx->blockState.prevCBlock->rep[i] = 0;
	assert(!ZSTD_window_hasExtDict(cctx->blockState.matchState.window));
	}

	/* These are the approximate sizes for each strategy past which copying the
	* dictionary tables into the working context is faster than using them
	* in-place.
	*/
	static const size_t attachDictSizeCutoffs[ZSTD_STRATEGY_MAX+1] = {
	8 KB, /* unused */
	8 KB, /* ZSTD_fast */
	16 KB, /* ZSTD_dfast */
	32 KB, /* ZSTD_greedy */
	32 KB, /* ZSTD_lazy */
	32 KB, /* ZSTD_lazy2 */
	32 KB, /* ZSTD_btlazy2 */
	32 KB, /* ZSTD_btopt */
	8 KB, /* ZSTD_btultra */
	8 KB /* ZSTD_btultra2 */
	};

	static int ZSTD_shouldAttachDict(const ZSTD_CDict* cdict,
	const ZSTD_CCtx_params* params,
	U64 pledgedSrcSize)
	{
	size_t cutoff = attachDictSizeCutoffs[cdict->matchState.cParams.strategy];
	return ( pledgedSrcSize <= cutoff
	\|\| pledgedSrcSize == ZSTD_CONTENTSIZE_UNKNOWN
	\|\| params->attachDictPref == ZSTD_dictForceAttach )
	&& params->attachDictPref != ZSTD_dictForceCopy
	&& !params->forceWindow; /* dictMatchState isn't correctly
	* handled in _enforceMaxDist */
	}

	static size_t
	ZSTD_resetCCtx_byAttachingCDict(ZSTD_CCtx* cctx,
	const ZSTD_CDict* cdict,
	ZSTD_CCtx_params params,
	U64 pledgedSrcSize,
	ZSTD_buffered_policy_e zbuff)
	{
	{ const ZSTD_compressionParameters* const cdict_cParams = &cdict->matchState.cParams;
	unsigned const windowLog = params.cParams.windowLog;
	assert(windowLog != 0);
	/* Resize working context table params for input only, since the dict
	* has its own tables. */
	/* pledgeSrcSize == 0 means 0! */
	params.cParams = ZSTD_adjustCParams_internal(*cdict_cParams, pledgedSrcSize, 0);
	params.cParams.windowLog = windowLog;
	FORWARD_IF_ERROR(ZSTD_resetCCtx_internal(cctx, params, pledgedSrcSize,
	ZSTDcrp_makeClean, zbuff), "");
	assert(cctx->appliedParams.cParams.strategy == cdict_cParams->strategy);
	}

	{ const U32 cdictEnd = (U32)( cdict->matchState.window.nextSrc
	- cdict->matchState.window.base);
	const U32 cdictLen = cdictEnd - cdict->matchState.window.dictLimit;
	if (cdictLen == 0) {
	/* don't even attach dictionaries with no contents */
	DEBUGLOG(4, "skipping attaching empty dictionary");
	} else {
	DEBUGLOG(4, "attaching dictionary into context");
	cctx->blockState.matchState.dictMatchState = &cdict->matchState;

	/* prep working match state so dict matches never have negative indices
	* when they are translated to the working context's index space. */
	if (cctx->blockState.matchState.window.dictLimit < cdictEnd) {
	cctx->blockState.matchState.window.nextSrc =
	cctx->blockState.matchState.window.base + cdictEnd;
	ZSTD_window_clear(&cctx->blockState.matchState.window);
	}
	/* loadedDictEnd is expressed within the referential of the active context */
	cctx->blockState.matchState.loadedDictEnd = cctx->blockState.matchState.window.dictLimit;
	} }

	cctx->dictID = cdict->dictID;

	/* copy block state */
	memcpy(cctx->blockState.prevCBlock, &cdict->cBlockState, sizeof(cdict->cBlockState));

	return 0;
	}

	static size_t ZSTD_resetCCtx_byCopyingCDict(ZSTD_CCtx* cctx,
	const ZSTD_CDict* cdict,
	ZSTD_CCtx_params params,
	U64 pledgedSrcSize,
	ZSTD_buffered_policy_e zbuff)
	{
	const ZSTD_compressionParameters *cdict_cParams = &cdict->matchState.cParams;

	DEBUGLOG(4, "copying dictionary into context");

	{ unsigned const windowLog = params.cParams.windowLog;
	assert(windowLog != 0);
	/* Copy only compression parameters related to tables. */
	params.cParams = *cdict_cParams;
	params.cParams.windowLog = windowLog;
	FORWARD_IF_ERROR(ZSTD_resetCCtx_internal(cctx, params, pledgedSrcSize,
	ZSTDcrp_leaveDirty, zbuff), "");
	assert(cctx->appliedParams.cParams.strategy == cdict_cParams->strategy);
	assert(cctx->appliedParams.cParams.hashLog == cdict_cParams->hashLog);
	assert(cctx->appliedParams.cParams.chainLog == cdict_cParams->chainLog);
	}

	ZSTD_cwksp_mark_tables_dirty(&cctx->workspace);

	/* copy tables */
	{ size_t const chainSize = (cdict_cParams->strategy == ZSTD_fast) ? 0 : ((size_t)1 << cdict_cParams->chainLog);
	size_t const hSize = (size_t)1 << cdict_cParams->hashLog;

	memcpy(cctx->blockState.matchState.hashTable,
	cdict->matchState.hashTable,
	hSize * sizeof(U32));
	memcpy(cctx->blockState.matchState.chainTable,
	cdict->matchState.chainTable,
	chainSize * sizeof(U32));
	}

	/* Zero the hashTable3, since the cdict never fills it */
	{ int const h3log = cctx->blockState.matchState.hashLog3;
	size_t const h3Size = h3log ? ((size_t)1 << h3log) : 0;
	assert(cdict->matchState.hashLog3 == 0);
	memset(cctx->blockState.matchState.hashTable3, 0, h3Size * sizeof(U32));
	}

	ZSTD_cwksp_mark_tables_clean(&cctx->workspace);

	/* copy dictionary offsets */
	{ ZSTD_matchState_t const* srcMatchState = &cdict->matchState;
	ZSTD_matchState_t* dstMatchState = &cctx->blockState.matchState;
	dstMatchState->window = srcMatchState->window;
	dstMatchState->nextToUpdate = srcMatchState->nextToUpdate;
	dstMatchState->loadedDictEnd= srcMatchState->loadedDictEnd;
	}

	cctx->dictID = cdict->dictID;

	/* copy block state */
	memcpy(cctx->blockState.prevCBlock, &cdict->cBlockState, sizeof(cdict->cBlockState));

	return 0;
	}

	/* We have a choice between copying the dictionary context into the working
	* context, or referencing the dictionary context from the working context
	* in-place. We decide here which strategy to use. */
	static size_t ZSTD_resetCCtx_usingCDict(ZSTD_CCtx* cctx,
	const ZSTD_CDict* cdict,
	const ZSTD_CCtx_params* params,
	U64 pledgedSrcSize,
	ZSTD_buffered_policy_e zbuff)
	{

	DEBUGLOG(4, "ZSTD_resetCCtx_usingCDict (pledgedSrcSize=%u)",
	(unsigned)pledgedSrcSize);

	if (ZSTD_shouldAttachDict(cdict, params, pledgedSrcSize)) {
	return ZSTD_resetCCtx_byAttachingCDict(
	cctx, cdict, *params, pledgedSrcSize, zbuff);
	} else {
	return ZSTD_resetCCtx_byCopyingCDict(
	cctx, cdict, *params, pledgedSrcSize, zbuff);
	}
	}

	/*! ZSTD_copyCCtx_internal() :
	* Duplicate an existing context `srcCCtx` into another one `dstCCtx`.
	* Only works during stage ZSTDcs_init (i.e. after creation, but before first call to ZSTD_compressContinue()).
	* The "context", in this case, refers to the hash and chain tables,
	* entropy tables, and dictionary references.
	* `windowLog` value is enforced if != 0, otherwise value is copied from srcCCtx.
	* @return : 0, or an error code */
	static size_t ZSTD_copyCCtx_internal(ZSTD_CCtx* dstCCtx,
	const ZSTD_CCtx* srcCCtx,
	ZSTD_frameParameters fParams,
	U64 pledgedSrcSize,
	ZSTD_buffered_policy_e zbuff)
	{
	DEBUGLOG(5, "ZSTD_copyCCtx_internal");
	RETURN_ERROR_IF(srcCCtx->stage!=ZSTDcs_init, stage_wrong,
	"Can't copy a ctx that's not in init stage.");

	memcpy(&dstCCtx->customMem, &srcCCtx->customMem, sizeof(ZSTD_customMem));
	{ ZSTD_CCtx_params params = dstCCtx->requestedParams;
	/* Copy only compression parameters related to tables. */
	params.cParams = srcCCtx->appliedParams.cParams;
	params.fParams = fParams;
	ZSTD_resetCCtx_internal(dstCCtx, params, pledgedSrcSize,
	ZSTDcrp_leaveDirty, zbuff);
	assert(dstCCtx->appliedParams.cParams.windowLog == srcCCtx->appliedParams.cParams.windowLog);
	assert(dstCCtx->appliedParams.cParams.strategy == srcCCtx->appliedParams.cParams.strategy);
	assert(dstCCtx->appliedParams.cParams.hashLog == srcCCtx->appliedParams.cParams.hashLog);
	assert(dstCCtx->appliedParams.cParams.chainLog == srcCCtx->appliedParams.cParams.chainLog);
	assert(dstCCtx->blockState.matchState.hashLog3 == srcCCtx->blockState.matchState.hashLog3);
	}

	ZSTD_cwksp_mark_tables_dirty(&dstCCtx->workspace);

	/* copy tables */
	{ size_t const chainSize = (srcCCtx->appliedParams.cParams.strategy == ZSTD_fast) ? 0 : ((size_t)1 << srcCCtx->appliedParams.cParams.chainLog);
	size_t const hSize = (size_t)1 << srcCCtx->appliedParams.cParams.hashLog;
	int const h3log = srcCCtx->blockState.matchState.hashLog3;
	size_t const h3Size = h3log ? ((size_t)1 << h3log) : 0;

	memcpy(dstCCtx->blockState.matchState.hashTable,
	srcCCtx->blockState.matchState.hashTable,
	hSize * sizeof(U32));
	memcpy(dstCCtx->blockState.matchState.chainTable,
	srcCCtx->blockState.matchState.chainTable,
	chainSize * sizeof(U32));
	memcpy(dstCCtx->blockState.matchState.hashTable3,
	srcCCtx->blockState.matchState.hashTable3,
	h3Size * sizeof(U32));
	}

	ZSTD_cwksp_mark_tables_clean(&dstCCtx->workspace);

	/* copy dictionary offsets */
	{
	const ZSTD_matchState_t* srcMatchState = &srcCCtx->blockState.matchState;
	ZSTD_matchState_t* dstMatchState = &dstCCtx->blockState.matchState;
	dstMatchState->window = srcMatchState->window;
	dstMatchState->nextToUpdate = srcMatchState->nextToUpdate;
	dstMatchState->loadedDictEnd= srcMatchState->loadedDictEnd;
	}
	dstCCtx->dictID = srcCCtx->dictID;

	/* copy block state */
	memcpy(dstCCtx->blockState.prevCBlock, srcCCtx->blockState.prevCBlock, sizeof(*srcCCtx->blockState.prevCBlock));

	return 0;
	}

	/*! ZSTD_copyCCtx() :
	* Duplicate an existing context `srcCCtx` into another one `dstCCtx`.
	* Only works during stage ZSTDcs_init (i.e. after creation, but before first call to ZSTD_compressContinue()).
	* pledgedSrcSize==0 means "unknown".
	* @return : 0, or an error code */
	size_t ZSTD_copyCCtx(ZSTD_CCtx* dstCCtx, const ZSTD_CCtx* srcCCtx, unsigned long long pledgedSrcSize)
	{
	ZSTD_frameParameters fParams = { 1 /content/, 0 /checksum/, 0 /noDictID/ };
	ZSTD_buffered_policy_e const zbuff = (ZSTD_buffered_policy_e)(srcCCtx->inBuffSize>0);
	ZSTD_STATIC_ASSERT((U32)ZSTDb_buffered==1);
	if (pledgedSrcSize==0) pledgedSrcSize = ZSTD_CONTENTSIZE_UNKNOWN;
	fParams.contentSizeFlag = (pledgedSrcSize != ZSTD_CONTENTSIZE_UNKNOWN);

	return ZSTD_copyCCtx_internal(dstCCtx, srcCCtx,
	fParams, pledgedSrcSize,
	zbuff);
	}


	#define ZSTD_ROWSIZE 16
	/*! ZSTD_reduceTable() :
	* reduce table indexes by `reducerValue`, or squash to zero.
	* PreserveMark preserves "unsorted mark" for btlazy2 strategy.
	* It must be set to a clear 0/1 value, to remove branch during inlining.
	* Presume table size is a multiple of ZSTD_ROWSIZE
	* to help auto-vectorization */
	FORCE_INLINE_TEMPLATE void
	ZSTD_reduceTable_internal (U32* const table, U32 const size, U32 const reducerValue, int const preserveMark)
	{
	int const nbRows = (int)size / ZSTD_ROWSIZE;
	int cellNb = 0;
	int rowNb;
	assert((size & (ZSTD_ROWSIZE-1)) == 0); /* multiple of ZSTD_ROWSIZE */
	assert(size < (1U<<31)); /* can be casted to int */

	#if defined (MEMORY_SANITIZER) && !defined (ZSTD_MSAN_DONT_POISON_WORKSPACE)
	/* To validate that the table re-use logic is sound, and that we don't
	* access table space that we haven't cleaned, we re-"poison" the table
	* space every time we mark it dirty.
	*
	* This function however is intended to operate on those dirty tables and
	* re-clean them. So when this function is used correctly, we can unpoison
	* the memory it operated on. This introduces a blind spot though, since
	* if we now try to operate on __actually__ poisoned memory, we will not
	* detect that. */
	__msan_unpoison(table, size * sizeof(U32));
	#endif

	for (rowNb=0 ; rowNb < nbRows ; rowNb++) {
	int column;
	for (column=0; column<ZSTD_ROWSIZE; column++) {
	if (preserveMark) {
	U32 const adder = (table[cellNb] == ZSTD_DUBT_UNSORTED_MARK) ? reducerValue : 0;
	table[cellNb] += adder;
	}
	if (table[cellNb] < reducerValue) table[cellNb] = 0;
	else table[cellNb] -= reducerValue;
	cellNb++;
	} }
	}

	static void ZSTD_reduceTable(U32* const table, U32 const size, U32 const reducerValue)
	{
	ZSTD_reduceTable_internal(table, size, reducerValue, 0);
	}

	static void ZSTD_reduceTable_btlazy2(U32* const table, U32 const size, U32 const reducerValue)
	{
	ZSTD_reduceTable_internal(table, size, reducerValue, 1);
	}

	/*! ZSTD_reduceIndex() :
	* rescale all indexes to avoid future overflow (indexes are U32) */
	static void ZSTD_reduceIndex (ZSTD_matchState_t* ms, ZSTD_CCtx_params const* params, const U32 reducerValue)
	{
	{ U32 const hSize = (U32)1 << params->cParams.hashLog;
	ZSTD_reduceTable(ms->hashTable, hSize, reducerValue);
	}

	if (params->cParams.strategy != ZSTD_fast) {
	U32 const chainSize = (U32)1 << params->cParams.chainLog;
	if (params->cParams.strategy == ZSTD_btlazy2)
	ZSTD_reduceTable_btlazy2(ms->chainTable, chainSize, reducerValue);
	else
	ZSTD_reduceTable(ms->chainTable, chainSize, reducerValue);
	}

	if (ms->hashLog3) {
	U32 const h3Size = (U32)1 << ms->hashLog3;
	ZSTD_reduceTable(ms->hashTable3, h3Size, reducerValue);
	}
	}


	/-******************************************************
	* Block entropic compression
	*********************************************************/

	/* See doc/zstd_compression_format.md for detailed format description */

	void ZSTD_seqToCodes(const seqStore_t* seqStorePtr)
	{
	const seqDef* const sequences = seqStorePtr->sequencesStart;
	BYTE* const llCodeTable = seqStorePtr->llCode;
	BYTE* const ofCodeTable = seqStorePtr->ofCode;
	BYTE* const mlCodeTable = seqStorePtr->mlCode;
	U32 const nbSeq = (U32)(seqStorePtr->sequences - seqStorePtr->sequencesStart);
	U32 u;
	assert(nbSeq <= seqStorePtr->maxNbSeq);
	for (u=0; u<nbSeq; u++) {
	U32 const llv = sequences[u].litLength;
	U32 const mlv = sequences[u].matchLength;
	llCodeTable[u] = (BYTE)ZSTD_LLcode(llv);
	ofCodeTable[u] = (BYTE)ZSTD_highbit32(sequences[u].offset);
	mlCodeTable[u] = (BYTE)ZSTD_MLcode(mlv);
	}
	if (seqStorePtr->longLengthID==1)
	llCodeTable[seqStorePtr->longLengthPos] = MaxLL;
	if (seqStorePtr->longLengthID==2)
	mlCodeTable[seqStorePtr->longLengthPos] = MaxML;
	}

	/* ZSTD_useTargetCBlockSize():
	* Returns if target compressed block size param is being used.
	* If used, compression will do best effort to make a compressed block size to be around targetCBlockSize.
	* Returns 1 if true, 0 otherwise. */
	static int ZSTD_useTargetCBlockSize(const ZSTD_CCtx_params* cctxParams)
	{
	DEBUGLOG(5, "ZSTD_useTargetCBlockSize (targetCBlockSize=%zu)", cctxParams->targetCBlockSize);
	return (cctxParams->targetCBlockSize != 0);
	}

	/* ZSTD_compressSequences_internal():
	* actually compresses both literals and sequences */
	MEM_STATIC size_t
	ZSTD_compressSequences_internal(seqStore_t* seqStorePtr,
	const ZSTD_entropyCTables_t* prevEntropy,
	ZSTD_entropyCTables_t* nextEntropy,
	const ZSTD_CCtx_params* cctxParams,
	void* dst, size_t dstCapacity,
	void* entropyWorkspace, size_t entropyWkspSize,
	const int bmi2)
	{
	const int longOffsets = cctxParams->cParams.windowLog > STREAM_ACCUMULATOR_MIN;
	ZSTD_strategy const strategy = cctxParams->cParams.strategy;
	unsigned count[MaxSeq+1];
	FSE_CTable* CTable_LitLength = nextEntropy->fse.litlengthCTable;
	FSE_CTable* CTable_OffsetBits = nextEntropy->fse.offcodeCTable;
	FSE_CTable* CTable_MatchLength = nextEntropy->fse.matchlengthCTable;
	U32 LLtype, Offtype, MLtype; /* compressed, raw or rle */
	const seqDef* const sequences = seqStorePtr->sequencesStart;
	const BYTE* const ofCodeTable = seqStorePtr->ofCode;
	const BYTE* const llCodeTable = seqStorePtr->llCode;
	const BYTE* const mlCodeTable = seqStorePtr->mlCode;
	BYTE* const ostart = (BYTE*)dst;
	BYTE* const oend = ostart + dstCapacity;
	BYTE* op = ostart;
	size_t const nbSeq = (size_t)(seqStorePtr->sequences - seqStorePtr->sequencesStart);
	BYTE* seqHead;
	BYTE* lastNCount = NULL;

	DEBUGLOG(5, "ZSTD_compressSequences_internal (nbSeq=%zu)", nbSeq);
	ZSTD_STATIC_ASSERT(HUF_WORKSPACE_SIZE >= (1<<MAX(MLFSELog,LLFSELog)));

	/* Compress literals */
	{ const BYTE* const literals = seqStorePtr->litStart;
	size_t const litSize = (size_t)(seqStorePtr->lit - literals);
	size_t const cSize = ZSTD_compressLiterals(
	&prevEntropy->huf, &nextEntropy->huf,
	cctxParams->cParams.strategy,
	ZSTD_disableLiteralsCompression(cctxParams),
	op, dstCapacity,
	literals, litSize,
	entropyWorkspace, entropyWkspSize,
	bmi2);
	FORWARD_IF_ERROR(cSize, "ZSTD_compressLiterals failed");
	assert(cSize <= dstCapacity);
	op += cSize;
	}

	/* Sequences Header */
	RETURN_ERROR_IF((oend-op) < 3 /max nbSeq Size/ + 1 /seqHead/,
	dstSize_tooSmall, "Can't fit seq hdr in output buf!");
	if (nbSeq < 128) {
	*op++ = (BYTE)nbSeq;
	} else if (nbSeq < LONGNBSEQ) {
	op[0] = (BYTE)((nbSeq>>8) + 0x80);
	op[1] = (BYTE)nbSeq;
	op+=2;
	} else {
	op[0]=0xFF;
	MEM_writeLE16(op+1, (U16)(nbSeq - LONGNBSEQ));
	op+=3;
	}
	assert(op <= oend);
	if (nbSeq==0) {
	/* Copy the old tables over as if we repeated them */
	memcpy(&nextEntropy->fse, &prevEntropy->fse, sizeof(prevEntropy->fse));
	return (size_t)(op - ostart);
	}

	/* seqHead : flags for FSE encoding type */
	seqHead = op++;
	assert(op <= oend);

	/* convert length/distances into codes */
	ZSTD_seqToCodes(seqStorePtr);
	/* build CTable for Literal Lengths */
	{ unsigned max = MaxLL;
	size_t const mostFrequent = HIST_countFast_wksp(count, &max, llCodeTable, nbSeq, entropyWorkspace, entropyWkspSize); /* can't fail */
	DEBUGLOG(5, "Building LL table");
	nextEntropy->fse.litlength_repeatMode = prevEntropy->fse.litlength_repeatMode;
	LLtype = ZSTD_selectEncodingType(&nextEntropy->fse.litlength_repeatMode,
	count, max, mostFrequent, nbSeq,
	LLFSELog, prevEntropy->fse.litlengthCTable,
	LL_defaultNorm, LL_defaultNormLog,
	ZSTD_defaultAllowed, strategy);
	assert(set_basic < set_compressed && set_rle < set_compressed);
	assert(!(LLtype < set_compressed && nextEntropy->fse.litlength_repeatMode != FSE_repeat_none)); /* We don't copy tables */
	{ size_t const countSize = ZSTD_buildCTable(
	op, (size_t)(oend - op),
	CTable_LitLength, LLFSELog, (symbolEncodingType_e)LLtype,
	count, max, llCodeTable, nbSeq,
	LL_defaultNorm, LL_defaultNormLog, MaxLL,
	prevEntropy->fse.litlengthCTable,
	sizeof(prevEntropy->fse.litlengthCTable),
	entropyWorkspace, entropyWkspSize);
	FORWARD_IF_ERROR(countSize, "ZSTD_buildCTable for LitLens failed");
	if (LLtype == set_compressed)
	lastNCount = op;
	op += countSize;
	assert(op <= oend);
	} }
	/* build CTable for Offsets */
	{ unsigned max = MaxOff;
	size_t const mostFrequent = HIST_countFast_wksp(
	count, &max, ofCodeTable, nbSeq, entropyWorkspace, entropyWkspSize); /* can't fail */
	/* We can only use the basic table if max <= DefaultMaxOff, otherwise the offsets are too large */
	ZSTD_defaultPolicy_e const defaultPolicy = (max <= DefaultMaxOff) ? ZSTD_defaultAllowed : ZSTD_defaultDisallowed;
	DEBUGLOG(5, "Building OF table");
	nextEntropy->fse.offcode_repeatMode = prevEntropy->fse.offcode_repeatMode;
	Offtype = ZSTD_selectEncodingType(&nextEntropy->fse.offcode_repeatMode,
	count, max, mostFrequent, nbSeq,
	OffFSELog, prevEntropy->fse.offcodeCTable,
	OF_defaultNorm, OF_defaultNormLog,
	defaultPolicy, strategy);
	assert(!(Offtype < set_compressed && nextEntropy->fse.offcode_repeatMode != FSE_repeat_none)); /* We don't copy tables */
	{ size_t const countSize = ZSTD_buildCTable(
	op, (size_t)(oend - op),
	CTable_OffsetBits, OffFSELog, (symbolEncodingType_e)Offtype,
	count, max, ofCodeTable, nbSeq,
	OF_defaultNorm, OF_defaultNormLog, DefaultMaxOff,
	prevEntropy->fse.offcodeCTable,
	sizeof(prevEntropy->fse.offcodeCTable),
	entropyWorkspace, entropyWkspSize);
	FORWARD_IF_ERROR(countSize, "ZSTD_buildCTable for Offsets failed");
	if (Offtype == set_compressed)
	lastNCount = op;
	op += countSize;
	assert(op <= oend);
	} }
	/* build CTable for MatchLengths */
	{ unsigned max = MaxML;
	size_t const mostFrequent = HIST_countFast_wksp(
	count, &max, mlCodeTable, nbSeq, entropyWorkspace, entropyWkspSize); /* can't fail */
	DEBUGLOG(5, "Building ML table (remaining space : %i)", (int)(oend-op));
	nextEntropy->fse.matchlength_repeatMode = prevEntropy->fse.matchlength_repeatMode;
	MLtype = ZSTD_selectEncodingType(&nextEntropy->fse.matchlength_repeatMode,
	count, max, mostFrequent, nbSeq,
	MLFSELog, prevEntropy->fse.matchlengthCTable,
	ML_defaultNorm, ML_defaultNormLog,
	ZSTD_defaultAllowed, strategy);
	assert(!(MLtype < set_compressed && nextEntropy->fse.matchlength_repeatMode != FSE_repeat_none)); /* We don't copy tables */
	{ size_t const countSize = ZSTD_buildCTable(
	op, (size_t)(oend - op),
	CTable_MatchLength, MLFSELog, (symbolEncodingType_e)MLtype,
	count, max, mlCodeTable, nbSeq,
	ML_defaultNorm, ML_defaultNormLog, MaxML,
	prevEntropy->fse.matchlengthCTable,
	sizeof(prevEntropy->fse.matchlengthCTable),
	entropyWorkspace, entropyWkspSize);
	FORWARD_IF_ERROR(countSize, "ZSTD_buildCTable for MatchLengths failed");
	if (MLtype == set_compressed)
	lastNCount = op;
	op += countSize;
	assert(op <= oend);
	} }

	*seqHead = (BYTE)((LLtype<<6) + (Offtype<<4) + (MLtype<<2));

	{ size_t const bitstreamSize = ZSTD_encodeSequences(
	op, (size_t)(oend - op),
	CTable_MatchLength, mlCodeTable,
	CTable_OffsetBits, ofCodeTable,
	CTable_LitLength, llCodeTable,
	sequences, nbSeq,
	longOffsets, bmi2);
	FORWARD_IF_ERROR(bitstreamSize, "ZSTD_encodeSequences failed");
	op += bitstreamSize;
	assert(op <= oend);
	/* zstd versions <= 1.3.4 mistakenly report corruption when
	* FSE_readNCount() receives a buffer < 4 bytes.
	* Fixed by https://github.com/facebook/zstd/pull/1146.
	* This can happen when the last set_compressed table present is 2
	* bytes and the bitstream is only one byte.
	* In this exceedingly rare case, we will simply emit an uncompressed
	* block, since it isn't worth optimizing.
	*/
	if (lastNCount && (op - lastNCount) < 4) {
	/* NCountSize >= 2 && bitstreamSize > 0 ==> lastCountSize == 3 */
	assert(op - lastNCount == 3);
	DEBUGLOG(5, "Avoiding bug in zstd decoder in versions <= 1.3.4 by "
	"emitting an uncompressed block.");
	return 0;
	}
	}

	DEBUGLOG(5, "compressed block size : %u", (unsigned)(op - ostart));
	return (size_t)(op - ostart);
	}

	MEM_STATIC size_t
	ZSTD_compressSequences(seqStore_t* seqStorePtr,
	const ZSTD_entropyCTables_t* prevEntropy,
	ZSTD_entropyCTables_t* nextEntropy,
	const ZSTD_CCtx_params* cctxParams,
	void* dst, size_t dstCapacity,
	size_t srcSize,
	void* entropyWorkspace, size_t entropyWkspSize,
	int bmi2)
	{
	size_t const cSize = ZSTD_compressSequences_internal(
	seqStorePtr, prevEntropy, nextEntropy, cctxParams,
	dst, dstCapacity,
	entropyWorkspace, entropyWkspSize, bmi2);
	if (cSize == 0) return 0;
	/* When srcSize <= dstCapacity, there is enough space to write a raw uncompressed block.
	* Since we ran out of space, block must be not compressible, so fall back to raw uncompressed block.
	*/
	if ((cSize == ERROR(dstSize_tooSmall)) & (srcSize <= dstCapacity))
	return 0; /* block not compressed */
	FORWARD_IF_ERROR(cSize, "ZSTD_compressSequences_internal failed");

	/* Check compressibility */
	{ size_t const maxCSize = srcSize - ZSTD_minGain(srcSize, cctxParams->cParams.strategy);
	if (cSize >= maxCSize) return 0; /* block not compressed */
	}

	return cSize;
	}

	/* ZSTD_selectBlockCompressor() :
	* Not static, but internal use only (used by long distance matcher)
	* assumption : strat is a valid strategy */
	ZSTD_blockCompressor ZSTD_selectBlockCompressor(ZSTD_strategy strat, ZSTD_dictMode_e dictMode)
	{
	static const ZSTD_blockCompressor blockCompressor[3][ZSTD_STRATEGY_MAX+1] = {
	{ ZSTD_compressBlock_fast /* default for 0 */,
	ZSTD_compressBlock_fast,
	ZSTD_compressBlock_doubleFast,
	ZSTD_compressBlock_greedy,
	ZSTD_compressBlock_lazy,
	ZSTD_compressBlock_lazy2,
	ZSTD_compressBlock_btlazy2,
	ZSTD_compressBlock_btopt,
	ZSTD_compressBlock_btultra,
	ZSTD_compressBlock_btultra2 },
	{ ZSTD_compressBlock_fast_extDict /* default for 0 */,
	ZSTD_compressBlock_fast_extDict,
	ZSTD_compressBlock_doubleFast_extDict,
	ZSTD_compressBlock_greedy_extDict,
	ZSTD_compressBlock_lazy_extDict,
	ZSTD_compressBlock_lazy2_extDict,
	ZSTD_compressBlock_btlazy2_extDict,
	ZSTD_compressBlock_btopt_extDict,
	ZSTD_compressBlock_btultra_extDict,
	ZSTD_compressBlock_btultra_extDict },
	{ ZSTD_compressBlock_fast_dictMatchState /* default for 0 */,
	ZSTD_compressBlock_fast_dictMatchState,
	ZSTD_compressBlock_doubleFast_dictMatchState,
	ZSTD_compressBlock_greedy_dictMatchState,
	ZSTD_compressBlock_lazy_dictMatchState,
	ZSTD_compressBlock_lazy2_dictMatchState,
	ZSTD_compressBlock_btlazy2_dictMatchState,
	ZSTD_compressBlock_btopt_dictMatchState,
	ZSTD_compressBlock_btultra_dictMatchState,
	ZSTD_compressBlock_btultra_dictMatchState }
	};
	ZSTD_blockCompressor selectedCompressor;
	ZSTD_STATIC_ASSERT((unsigned)ZSTD_fast == 1);

	assert(ZSTD_cParam_withinBounds(ZSTD_c_strategy, strat));
	selectedCompressor = blockCompressor[(int)dictMode][(int)strat];
	assert(selectedCompressor != NULL);
	return selectedCompressor;
	}

	static void ZSTD_storeLastLiterals(seqStore_t* seqStorePtr,
	const BYTE* anchor, size_t lastLLSize)
	{
	memcpy(seqStorePtr->lit, anchor, lastLLSize);
	seqStorePtr->lit += lastLLSize;
	}

	void ZSTD_resetSeqStore(seqStore_t* ssPtr)
	{
	ssPtr->lit = ssPtr->litStart;
	ssPtr->sequences = ssPtr->sequencesStart;
	ssPtr->longLengthID = 0;
	}

	typedef enum { ZSTDbss_compress, ZSTDbss_noCompress } ZSTD_buildSeqStore_e;

	static size_t ZSTD_buildSeqStore(ZSTD_CCtx* zc, const void* src, size_t srcSize)
	{
	ZSTD_matchState_t* const ms = &zc->blockState.matchState;
	DEBUGLOG(5, "ZSTD_buildSeqStore (srcSize=%zu)", srcSize);
	assert(srcSize <= ZSTD_BLOCKSIZE_MAX);
	/* Assert that we have correctly flushed the ctx params into the ms's copy */
	ZSTD_assertEqualCParams(zc->appliedParams.cParams, ms->cParams);
	if (srcSize < MIN_CBLOCK_SIZE+ZSTD_blockHeaderSize+1) {
	ZSTD_ldm_skipSequences(&zc->externSeqStore, srcSize, zc->appliedParams.cParams.minMatch);
	return ZSTDbss_noCompress; /* don't even attempt compression below a certain srcSize */
	}
	ZSTD_resetSeqStore(&(zc->seqStore));
	/* required for optimal parser to read stats from dictionary */
	ms->opt.symbolCosts = &zc->blockState.prevCBlock->entropy;
	/* tell the optimal parser how we expect to compress literals */
	ms->opt.literalCompressionMode = zc->appliedParams.literalCompressionMode;
	/* a gap between an attached dict and the current window is not safe,
	* they must remain adjacent,
	* and when that stops being the case, the dict must be unset */
	assert(ms->dictMatchState == NULL \|\| ms->loadedDictEnd == ms->window.dictLimit);

	/* limited update after a very long match */
	{ const BYTE* const base = ms->window.base;
	const BYTE* const istart = (const BYTE*)src;
	const U32 current = (U32)(istart-base);
	if (sizeof(ptrdiff_t)==8) assert(istart - base < (ptrdiff_t)(U32)(-1)); /* ensure no overflow */
	if (current > ms->nextToUpdate + 384)
	ms->nextToUpdate = current - MIN(192, (U32)(current - ms->nextToUpdate - 384));
	}

	/* select and store sequences */
	{ ZSTD_dictMode_e const dictMode = ZSTD_matchState_dictMode(ms);
	size_t lastLLSize;
	{ int i;
	for (i = 0; i < ZSTD_REP_NUM; ++i)
	zc->blockState.nextCBlock->rep[i] = zc->blockState.prevCBlock->rep[i];
	}
	if (zc->externSeqStore.pos < zc->externSeqStore.size) {
	assert(!zc->appliedParams.ldmParams.enableLdm);
	/* Updates ldmSeqStore.pos */
	lastLLSize =
	ZSTD_ldm_blockCompress(&zc->externSeqStore,
	ms, &zc->seqStore,
	zc->blockState.nextCBlock->rep,
	src, srcSize);
	assert(zc->externSeqStore.pos <= zc->externSeqStore.size);
	} else if (zc->appliedParams.ldmParams.enableLdm) {
	rawSeqStore_t ldmSeqStore = {NULL, 0, 0, 0};

	ldmSeqStore.seq = zc->ldmSequences;
	ldmSeqStore.capacity = zc->maxNbLdmSequences;
	/* Updates ldmSeqStore.size */
	FORWARD_IF_ERROR(ZSTD_ldm_generateSequences(&zc->ldmState, &ldmSeqStore,
	&zc->appliedParams.ldmParams,
	src, srcSize), "");
	/* Updates ldmSeqStore.pos */
	lastLLSize =
	ZSTD_ldm_blockCompress(&ldmSeqStore,
	ms, &zc->seqStore,
	zc->blockState.nextCBlock->rep,
	src, srcSize);
	assert(ldmSeqStore.pos == ldmSeqStore.size);
	} else { /* not long range mode */
	ZSTD_blockCompressor const blockCompressor = ZSTD_selectBlockCompressor(zc->appliedParams.cParams.strategy, dictMode);
	lastLLSize = blockCompressor(ms, &zc->seqStore, zc->blockState.nextCBlock->rep, src, srcSize);
	}
	{ const BYTE* const lastLiterals = (const BYTE*)src + srcSize - lastLLSize;
	ZSTD_storeLastLiterals(&zc->seqStore, lastLiterals, lastLLSize);
	} }
	return ZSTDbss_compress;
	}

	static void ZSTD_copyBlockSequences(ZSTD_CCtx* zc)
	{
	const seqStore_t* seqStore = ZSTD_getSeqStore(zc);
	const seqDef* seqs = seqStore->sequencesStart;
	size_t seqsSize = seqStore->sequences - seqs;

	ZSTD_Sequence* outSeqs = &zc->seqCollector.seqStart[zc->seqCollector.seqIndex];
	size_t i; size_t position; int repIdx;

	assert(zc->seqCollector.seqIndex + 1 < zc->seqCollector.maxSequences);
	for (i = 0, position = 0; i < seqsSize; ++i) {
	outSeqs[i].offset = seqs[i].offset;
	outSeqs[i].litLength = seqs[i].litLength;
	outSeqs[i].matchLength = seqs[i].matchLength + MINMATCH;

	if (i == seqStore->longLengthPos) {
	if (seqStore->longLengthID == 1) {
	outSeqs[i].litLength += 0x10000;
	} else if (seqStore->longLengthID == 2) {
	outSeqs[i].matchLength += 0x10000;
	}
	}

	if (outSeqs[i].offset <= ZSTD_REP_NUM) {
	outSeqs[i].rep = outSeqs[i].offset;
	repIdx = (unsigned int)i - outSeqs[i].offset;

	if (outSeqs[i].litLength == 0) {
	if (outSeqs[i].offset < 3) {
	--repIdx;
	} else {
	repIdx = (unsigned int)i - 1;
	}
	++outSeqs[i].rep;
	}
	assert(repIdx >= -3);
	outSeqs[i].offset = repIdx >= 0 ? outSeqs[repIdx].offset : repStartValue[-repIdx - 1];
	if (outSeqs[i].rep == 4) {
	--outSeqs[i].offset;
	}
	} else {
	outSeqs[i].offset -= ZSTD_REP_NUM;
	}

	position += outSeqs[i].litLength;
	outSeqs[i].matchPos = (unsigned int)position;
	position += outSeqs[i].matchLength;
	}
	zc->seqCollector.seqIndex += seqsSize;
	}

	size_t ZSTD_getSequences(ZSTD_CCtx* zc, ZSTD_Sequence* outSeqs,
	size_t outSeqsSize, const void* src, size_t srcSize)
	{
	const size_t dstCapacity = ZSTD_compressBound(srcSize);
	void* dst = ZSTD_malloc(dstCapacity, ZSTD_defaultCMem);
	SeqCollector seqCollector;

	RETURN_ERROR_IF(dst == NULL, memory_allocation, "NULL pointer!");

	seqCollector.collectSequences = 1;
	seqCollector.seqStart = outSeqs;
	seqCollector.seqIndex = 0;
	seqCollector.maxSequences = outSeqsSize;
	zc->seqCollector = seqCollector;

	ZSTD_compress2(zc, dst, dstCapacity, src, srcSize);
	ZSTD_free(dst, ZSTD_defaultCMem);
	return zc->seqCollector.seqIndex;
	}

	/* Returns true if the given block is a RLE block */
	static int ZSTD_isRLE(const BYTE *ip, size_t length) {
	size_t i;
	if (length < 2) return 1;
	for (i = 1; i < length; ++i) {
	if (ip[0] != ip[i]) return 0;
	}
	return 1;
	}

	/* Returns true if the given block may be RLE.
	* This is just a heuristic based on the compressibility.
	* It may return both false positives and false negatives.
	*/
	static int ZSTD_maybeRLE(seqStore_t const* seqStore)
	{
	size_t const nbSeqs = (size_t)(seqStore->sequences - seqStore->sequencesStart);
	size_t const nbLits = (size_t)(seqStore->lit - seqStore->litStart);

	return nbSeqs < 4 && nbLits < 10;
	}

	static void ZSTD_confirmRepcodesAndEntropyTables(ZSTD_CCtx* zc)
	{
	ZSTD_compressedBlockState_t* const tmp = zc->blockState.prevCBlock;
	zc->blockState.prevCBlock = zc->blockState.nextCBlock;
	zc->blockState.nextCBlock = tmp;
	}

	static size_t ZSTD_compressBlock_internal(ZSTD_CCtx* zc,
	void* dst, size_t dstCapacity,
	const void* src, size_t srcSize, U32 frame)
	{
	/* This the upper bound for the length of an rle block.
	* This isn't the actual upper bound. Finding the real threshold
	* needs further investigation.
	*/
	const U32 rleMaxLength = 25;
	size_t cSize;
	const BYTE* ip = (const BYTE*)src;
	BYTE* op = (BYTE*)dst;
	DEBUGLOG(5, "ZSTD_compressBlock_internal (dstCapacity=%u, dictLimit=%u, nextToUpdate=%u)",
	(unsigned)dstCapacity, (unsigned)zc->blockState.matchState.window.dictLimit,
	(unsigned)zc->blockState.matchState.nextToUpdate);

	{ const size_t bss = ZSTD_buildSeqStore(zc, src, srcSize);
	FORWARD_IF_ERROR(bss, "ZSTD_buildSeqStore failed");
	if (bss == ZSTDbss_noCompress) { cSize = 0; goto out; }
	}

	if (zc->seqCollector.collectSequences) {
	ZSTD_copyBlockSequences(zc);
	return 0;
	}

	/* encode sequences and literals */
	cSize = ZSTD_compressSequences(&zc->seqStore,
	&zc->blockState.prevCBlock->entropy, &zc->blockState.nextCBlock->entropy,
	&zc->appliedParams,
	dst, dstCapacity,
	srcSize,
	zc->entropyWorkspace, HUF_WORKSPACE_SIZE /* statically allocated in resetCCtx */,
	zc->bmi2);

	if (frame &&
	/* We don't want to emit our first block as a RLE even if it qualifies because
	* doing so will cause the decoder (cli only) to throw a "should consume all input error."
	* This is only an issue for zstd <= v1.4.3
	*/
	!zc->isFirstBlock &&
	cSize < rleMaxLength &&
	ZSTD_isRLE(ip, srcSize))
	{
	cSize = 1;
	op[0] = ip[0];
	}

	out:
	if (!ZSTD_isError(cSize) && cSize > 1) {
	ZSTD_confirmRepcodesAndEntropyTables(zc);
	}
	/* We check that dictionaries have offset codes available for the first
	* block. After the first block, the offcode table might not have large
	* enough codes to represent the offsets in the data.
	*/
	if (zc->blockState.prevCBlock->entropy.fse.offcode_repeatMode == FSE_repeat_valid)
	zc->blockState.prevCBlock->entropy.fse.offcode_repeatMode = FSE_repeat_check;

	return cSize;
	}

	static size_t ZSTD_compressBlock_targetCBlockSize_body(ZSTD_CCtx* zc,
	void* dst, size_t dstCapacity,
	const void* src, size_t srcSize,
	const size_t bss, U32 lastBlock)
	{
	DEBUGLOG(6, "Attempting ZSTD_compressSuperBlock()");
	if (bss == ZSTDbss_compress) {
	if (/* We don't want to emit our first block as a RLE even if it qualifies because
	* doing so will cause the decoder (cli only) to throw a "should consume all input error."
	* This is only an issue for zstd <= v1.4.3
	*/
	!zc->isFirstBlock &&
	ZSTD_maybeRLE(&zc->seqStore) &&
	ZSTD_isRLE((BYTE const*)src, srcSize))
	{
	return ZSTD_rleCompressBlock(dst, dstCapacity, (BYTE const)src, srcSize, lastBlock);
	}
	/* Attempt superblock compression.
	*
	* Note that compressed size of ZSTD_compressSuperBlock() is not bound by the
	* standard ZSTD_compressBound(). This is a problem, because even if we have
	* space now, taking an extra byte now could cause us to run out of space later
	* and violate ZSTD_compressBound().
	*
	* Define blockBound(blockSize) = blockSize + ZSTD_blockHeaderSize.
	*
	* In order to respect ZSTD_compressBound() we must attempt to emit a raw
	* uncompressed block in these cases:
	* * cSize == 0: Return code for an uncompressed block.
	* * cSize == dstSize_tooSmall: We may have expanded beyond blockBound(srcSize).
	* ZSTD_noCompressBlock() will return dstSize_tooSmall if we are really out of
	* output space.
	* * cSize >= blockBound(srcSize): We have expanded the block too much so
	* emit an uncompressed block.
	*/
	{
	size_t const cSize = ZSTD_compressSuperBlock(zc, dst, dstCapacity, src, srcSize, lastBlock);
	if (cSize != ERROR(dstSize_tooSmall)) {
	size_t const maxCSize = srcSize - ZSTD_minGain(srcSize, zc->appliedParams.cParams.strategy);
	FORWARD_IF_ERROR(cSize, "ZSTD_compressSuperBlock failed");
	if (cSize != 0 && cSize < maxCSize + ZSTD_blockHeaderSize) {
	ZSTD_confirmRepcodesAndEntropyTables(zc);
	return cSize;
	}
	}
	}
	}

	DEBUGLOG(6, "Resorting to ZSTD_noCompressBlock()");
	/* Superblock compression failed, attempt to emit a single no compress block.
	* The decoder will be able to stream this block since it is uncompressed.
	*/
	return ZSTD_noCompressBlock(dst, dstCapacity, src, srcSize, lastBlock);
	}

	static size_t ZSTD_compressBlock_targetCBlockSize(ZSTD_CCtx* zc,
	void* dst, size_t dstCapacity,
	const void* src, size_t srcSize,
	U32 lastBlock)
	{
	size_t cSize = 0;
	const size_t bss = ZSTD_buildSeqStore(zc, src, srcSize);
	DEBUGLOG(5, "ZSTD_compressBlock_targetCBlockSize (dstCapacity=%u, dictLimit=%u, nextToUpdate=%u, srcSize=%zu)",
	(unsigned)dstCapacity, (unsigned)zc->blockState.matchState.window.dictLimit, (unsigned)zc->blockState.matchState.nextToUpdate, srcSize);
	FORWARD_IF_ERROR(bss, "ZSTD_buildSeqStore failed");

	cSize = ZSTD_compressBlock_targetCBlockSize_body(zc, dst, dstCapacity, src, srcSize, bss, lastBlock);
	FORWARD_IF_ERROR(cSize, "ZSTD_compressBlock_targetCBlockSize_body failed");

	if (zc->blockState.prevCBlock->entropy.fse.offcode_repeatMode == FSE_repeat_valid)
	zc->blockState.prevCBlock->entropy.fse.offcode_repeatMode = FSE_repeat_check;

	return cSize;
	}

	static void ZSTD_overflowCorrectIfNeeded(ZSTD_matchState_t* ms,
	ZSTD_cwksp* ws,
	ZSTD_CCtx_params const* params,
	void const* ip,
	void const* iend)
	{
	if (ZSTD_window_needOverflowCorrection(ms->window, iend)) {
	U32 const maxDist = (U32)1 << params->cParams.windowLog;
	U32 const cycleLog = ZSTD_cycleLog(params->cParams.chainLog, params->cParams.strategy);
	U32 const correction = ZSTD_window_correctOverflow(&ms->window, cycleLog, maxDist, ip);
	ZSTD_STATIC_ASSERT(ZSTD_CHAINLOG_MAX <= 30);
	ZSTD_STATIC_ASSERT(ZSTD_WINDOWLOG_MAX_32 <= 30);
	ZSTD_STATIC_ASSERT(ZSTD_WINDOWLOG_MAX <= 31);
	ZSTD_cwksp_mark_tables_dirty(ws);
	ZSTD_reduceIndex(ms, params, correction);
	ZSTD_cwksp_mark_tables_clean(ws);
	if (ms->nextToUpdate < correction) ms->nextToUpdate = 0;
	else ms->nextToUpdate -= correction;
	/* invalidate dictionaries on overflow correction */
	ms->loadedDictEnd = 0;
	ms->dictMatchState = NULL;
	}
	}

	/*! ZSTD_compress_frameChunk() :
	* Compress a chunk of data into one or multiple blocks.
	* All blocks will be terminated, all input will be consumed.
	* Function will issue an error if there is not enough `dstCapacity` to hold the compressed content.
	* Frame is supposed already started (header already produced)
	* @return : compressed size, or an error code
	*/
	static size_t ZSTD_compress_frameChunk (ZSTD_CCtx* cctx,
	void* dst, size_t dstCapacity,
	const void* src, size_t srcSize,
	U32 lastFrameChunk)
	{
	size_t blockSize = cctx->blockSize;
	size_t remaining = srcSize;
	const BYTE* ip = (const BYTE*)src;
	BYTE* const ostart = (BYTE*)dst;
	BYTE* op = ostart;
	U32 const maxDist = (U32)1 << cctx->appliedParams.cParams.windowLog;

	assert(cctx->appliedParams.cParams.windowLog <= ZSTD_WINDOWLOG_MAX);

	DEBUGLOG(5, "ZSTD_compress_frameChunk (blockSize=%u)", (unsigned)blockSize);
	if (cctx->appliedParams.fParams.checksumFlag && srcSize)
	XXH64_update(&cctx->xxhState, src, srcSize);

	while (remaining) {
	ZSTD_matchState_t* const ms = &cctx->blockState.matchState;
	U32 const lastBlock = lastFrameChunk & (blockSize >= remaining);

	RETURN_ERROR_IF(dstCapacity < ZSTD_blockHeaderSize + MIN_CBLOCK_SIZE,
	dstSize_tooSmall,
	"not enough space to store compressed block");
	if (remaining < blockSize) blockSize = remaining;

	ZSTD_overflowCorrectIfNeeded(
	ms, &cctx->workspace, &cctx->appliedParams, ip, ip + blockSize);
	ZSTD_checkDictValidity(&ms->window, ip + blockSize, maxDist, &ms->loadedDictEnd, &ms->dictMatchState);

	/* Ensure hash/chain table insertion resumes no sooner than lowlimit */
	if (ms->nextToUpdate < ms->window.lowLimit) ms->nextToUpdate = ms->window.lowLimit;

	{ size_t cSize;
	if (ZSTD_useTargetCBlockSize(&cctx->appliedParams)) {
	cSize = ZSTD_compressBlock_targetCBlockSize(cctx, op, dstCapacity, ip, blockSize, lastBlock);
	FORWARD_IF_ERROR(cSize, "ZSTD_compressBlock_targetCBlockSize failed");
	assert(cSize > 0);
	assert(cSize <= blockSize + ZSTD_blockHeaderSize);
	} else {
	cSize = ZSTD_compressBlock_internal(cctx,
	op+ZSTD_blockHeaderSize, dstCapacity-ZSTD_blockHeaderSize,
	ip, blockSize, 1 /* frame */);
	FORWARD_IF_ERROR(cSize, "ZSTD_compressBlock_internal failed");

	if (cSize == 0) { /* block is not compressible */
	cSize = ZSTD_noCompressBlock(op, dstCapacity, ip, blockSize, lastBlock);
	FORWARD_IF_ERROR(cSize, "ZSTD_noCompressBlock failed");
	} else {
	U32 const cBlockHeader = cSize == 1 ?
	lastBlock + (((U32)bt_rle)<<1) + (U32)(blockSize << 3) :
	lastBlock + (((U32)bt_compressed)<<1) + (U32)(cSize << 3);
	MEM_writeLE24(op, cBlockHeader);
	cSize += ZSTD_blockHeaderSize;
	}
	}


	ip += blockSize;
	assert(remaining >= blockSize);
	remaining -= blockSize;
	op += cSize;
	assert(dstCapacity >= cSize);
	dstCapacity -= cSize;
	cctx->isFirstBlock = 0;
	DEBUGLOG(5, "ZSTD_compress_frameChunk: adding a block of size %u",
	(unsigned)cSize);
	} }

	if (lastFrameChunk && (op>ostart)) cctx->stage = ZSTDcs_ending;
	return (size_t)(op-ostart);
	}


	static size_t ZSTD_writeFrameHeader(void* dst, size_t dstCapacity,
	const ZSTD_CCtx_params* params, U64 pledgedSrcSize, U32 dictID)
	{ BYTE* const op = (BYTE*)dst;
	U32 const dictIDSizeCodeLength = (dictID>0) + (dictID>=256) + (dictID>=65536); /* 0-3 */
	U32 const dictIDSizeCode = params->fParams.noDictIDFlag ? 0 : dictIDSizeCodeLength; /* 0-3 */
	U32 const checksumFlag = params->fParams.checksumFlag>0;
	U32 const windowSize = (U32)1 << params->cParams.windowLog;
	U32 const singleSegment = params->fParams.contentSizeFlag && (windowSize >= pledgedSrcSize);
	BYTE const windowLogByte = (BYTE)((params->cParams.windowLog - ZSTD_WINDOWLOG_ABSOLUTEMIN) << 3);
	U32 const fcsCode = params->fParams.contentSizeFlag ?
	(pledgedSrcSize>=256) + (pledgedSrcSize>=65536+256) + (pledgedSrcSize>=0xFFFFFFFFU) : 0; /* 0-3 */
	BYTE const frameHeaderDescriptionByte = (BYTE)(dictIDSizeCode + (checksumFlag<<2) + (singleSegment<<5) + (fcsCode<<6) );
	size_t pos=0;

	assert(!(params->fParams.contentSizeFlag && pledgedSrcSize == ZSTD_CONTENTSIZE_UNKNOWN));
	RETURN_ERROR_IF(dstCapacity < ZSTD_FRAMEHEADERSIZE_MAX, dstSize_tooSmall,
	"dst buf is too small to fit worst-case frame header size.");
	DEBUGLOG(4, "ZSTD_writeFrameHeader : dictIDFlag : %u ; dictID : %u ; dictIDSizeCode : %u",
	!params->fParams.noDictIDFlag, (unsigned)dictID, (unsigned)dictIDSizeCode);

	if (params->format == ZSTD_f_zstd1) {
	MEM_writeLE32(dst, ZSTD_MAGICNUMBER);
	pos = 4;
	}
	op[pos++] = frameHeaderDescriptionByte;
	if (!singleSegment) op[pos++] = windowLogByte;
	switch(dictIDSizeCode)
	{
	default: assert(0); /* impossible */
	case 0 : break;
	case 1 : op[pos] = (BYTE)(dictID); pos++; break;
	case 2 : MEM_writeLE16(op+pos, (U16)dictID); pos+=2; break;
	case 3 : MEM_writeLE32(op+pos, dictID); pos+=4; break;
	}
	switch(fcsCode)
	{
	default: assert(0); /* impossible */
	case 0 : if (singleSegment) op[pos++] = (BYTE)(pledgedSrcSize); break;
	case 1 : MEM_writeLE16(op+pos, (U16)(pledgedSrcSize-256)); pos+=2; break;
	case 2 : MEM_writeLE32(op+pos, (U32)(pledgedSrcSize)); pos+=4; break;
	case 3 : MEM_writeLE64(op+pos, (U64)(pledgedSrcSize)); pos+=8; break;
	}
	return pos;
	}

	/* ZSTD_writeLastEmptyBlock() :
	* output an empty Block with end-of-frame mark to complete a frame
	* @return : size of data written into `dst` (== ZSTD_blockHeaderSize (defined in zstd_internal.h))
	* or an error code if `dstCapacity` is too small (<ZSTD_blockHeaderSize)
	*/
	size_t ZSTD_writeLastEmptyBlock(void* dst, size_t dstCapacity)
	{
	RETURN_ERROR_IF(dstCapacity < ZSTD_blockHeaderSize, dstSize_tooSmall,
	"dst buf is too small to write frame trailer empty block.");
	{ U32 const cBlockHeader24 = 1 /lastBlock/ + (((U32)bt_raw)<<1); /* 0 size */
	MEM_writeLE24(dst, cBlockHeader24);
	return ZSTD_blockHeaderSize;
	}
	}

	size_t ZSTD_referenceExternalSequences(ZSTD_CCtx* cctx, rawSeq* seq, size_t nbSeq)
	{
	RETURN_ERROR_IF(cctx->stage != ZSTDcs_init, stage_wrong,
	"wrong cctx stage");
	RETURN_ERROR_IF(cctx->appliedParams.ldmParams.enableLdm,
	parameter_unsupported,
	"incompatible with ldm");
	cctx->externSeqStore.seq = seq;
	cctx->externSeqStore.size = nbSeq;
	cctx->externSeqStore.capacity = nbSeq;
	cctx->externSeqStore.pos = 0;
	return 0;
	}


	static size_t ZSTD_compressContinue_internal (ZSTD_CCtx* cctx,
	void* dst, size_t dstCapacity,
	const void* src, size_t srcSize,
	U32 frame, U32 lastFrameChunk)
	{
	ZSTD_matchState_t* const ms = &cctx->blockState.matchState;
	size_t fhSize = 0;

	DEBUGLOG(5, "ZSTD_compressContinue_internal, stage: %u, srcSize: %u",
	cctx->stage, (unsigned)srcSize);
	RETURN_ERROR_IF(cctx->stage==ZSTDcs_created, stage_wrong,
	"missing init (ZSTD_compressBegin)");

	if (frame && (cctx->stage==ZSTDcs_init)) {
	fhSize = ZSTD_writeFrameHeader(dst, dstCapacity, &cctx->appliedParams,
	cctx->pledgedSrcSizePlusOne-1, cctx->dictID);
	FORWARD_IF_ERROR(fhSize, "ZSTD_writeFrameHeader failed");
	assert(fhSize <= dstCapacity);
	dstCapacity -= fhSize;
	dst = (char*)dst + fhSize;
	cctx->stage = ZSTDcs_ongoing;
	}

	if (!srcSize) return fhSize; /* do not generate an empty block if no input */

	if (!ZSTD_window_update(&ms->window, src, srcSize)) {
	ms->nextToUpdate = ms->window.dictLimit;
	}
	if (cctx->appliedParams.ldmParams.enableLdm) {
	ZSTD_window_update(&cctx->ldmState.window, src, srcSize);
	}

	if (!frame) {
	/* overflow check and correction for block mode */
	ZSTD_overflowCorrectIfNeeded(
	ms, &cctx->workspace, &cctx->appliedParams,
	src, (BYTE const*)src + srcSize);
	}

	DEBUGLOG(5, "ZSTD_compressContinue_internal (blockSize=%u)", (unsigned)cctx->blockSize);
	{ size_t const cSize = frame ?
	ZSTD_compress_frameChunk (cctx, dst, dstCapacity, src, srcSize, lastFrameChunk) :
	ZSTD_compressBlock_internal (cctx, dst, dstCapacity, src, srcSize, 0 /* frame */);
	FORWARD_IF_ERROR(cSize, "%s", frame ? "ZSTD_compress_frameChunk failed" : "ZSTD_compressBlock_internal failed");
	cctx->consumedSrcSize += srcSize;
	cctx->producedCSize += (cSize + fhSize);
	assert(!(cctx->appliedParams.fParams.contentSizeFlag && cctx->pledgedSrcSizePlusOne == 0));
	if (cctx->pledgedSrcSizePlusOne != 0) { /* control src size */
	ZSTD_STATIC_ASSERT(ZSTD_CONTENTSIZE_UNKNOWN == (unsigned long long)-1);
	RETURN_ERROR_IF(
	cctx->consumedSrcSize+1 > cctx->pledgedSrcSizePlusOne,
	srcSize_wrong,
	"error : pledgedSrcSize = %u, while realSrcSize >= %u",
	(unsigned)cctx->pledgedSrcSizePlusOne-1,
	(unsigned)cctx->consumedSrcSize);
	}
	return cSize + fhSize;
	}
	}

	size_t ZSTD_compressContinue (ZSTD_CCtx* cctx,
	void* dst, size_t dstCapacity,
	const void* src, size_t srcSize)
	{
	DEBUGLOG(5, "ZSTD_compressContinue (srcSize=%u)", (unsigned)srcSize);
	return ZSTD_compressContinue_internal(cctx, dst, dstCapacity, src, srcSize, 1 /* frame mode /, 0 / last chunk */);
	}


	size_t ZSTD_getBlockSize(const ZSTD_CCtx* cctx)
	{
	ZSTD_compressionParameters const cParams = cctx->appliedParams.cParams;
	assert(!ZSTD_checkCParams(cParams));
	return MIN (ZSTD_BLOCKSIZE_MAX, (U32)1 << cParams.windowLog);
	}

	size_t ZSTD_compressBlock(ZSTD_CCtx* cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize)
	{
	DEBUGLOG(5, "ZSTD_compressBlock: srcSize = %u", (unsigned)srcSize);
	{ size_t const blockSizeMax = ZSTD_getBlockSize(cctx);
	RETURN_ERROR_IF(srcSize > blockSizeMax, srcSize_wrong, "input is larger than a block"); }

	return ZSTD_compressContinue_internal(cctx, dst, dstCapacity, src, srcSize, 0 /* frame mode /, 0 / last chunk */);
	}

	/*! ZSTD_loadDictionaryContent() :
	* @return : 0, or an error code
	*/
	static size_t ZSTD_loadDictionaryContent(ZSTD_matchState_t* ms,
	ldmState_t* ls,
	ZSTD_cwksp* ws,
	ZSTD_CCtx_params const* params,
	const void* src, size_t srcSize,
	ZSTD_dictTableLoadMethod_e dtlm)
	{
	const BYTE* ip = (const BYTE*) src;
	const BYTE* const iend = ip + srcSize;

	ZSTD_window_update(&ms->window, src, srcSize);
	ms->loadedDictEnd = params->forceWindow ? 0 : (U32)(iend - ms->window.base);

	if (params->ldmParams.enableLdm && ls != NULL) {
	ZSTD_window_update(&ls->window, src, srcSize);
	ls->loadedDictEnd = params->forceWindow ? 0 : (U32)(iend - ls->window.base);
	}

	/* Assert that we the ms params match the params we're being given */
	ZSTD_assertEqualCParams(params->cParams, ms->cParams);

	if (srcSize <= HASH_READ_SIZE) return 0;

	while (iend - ip > HASH_READ_SIZE) {
	size_t const remaining = (size_t)(iend - ip);
	size_t const chunk = MIN(remaining, ZSTD_CHUNKSIZE_MAX);
	const BYTE* const ichunk = ip + chunk;

	ZSTD_overflowCorrectIfNeeded(ms, ws, params, ip, ichunk);

	if (params->ldmParams.enableLdm && ls != NULL)
	ZSTD_ldm_fillHashTable(ls, (const BYTE)src, (const BYTE)src + srcSize, &params->ldmParams);

	switch(params->cParams.strategy)
	{
	case ZSTD_fast:
	ZSTD_fillHashTable(ms, ichunk, dtlm);
	break;
	case ZSTD_dfast:
	ZSTD_fillDoubleHashTable(ms, ichunk, dtlm);
	break;

	case ZSTD_greedy:
	case ZSTD_lazy:
	case ZSTD_lazy2:
	if (chunk >= HASH_READ_SIZE)
	ZSTD_insertAndFindFirstIndex(ms, ichunk-HASH_READ_SIZE);
	break;

	case ZSTD_btlazy2: /* we want the dictionary table fully sorted */
	case ZSTD_btopt:
	case ZSTD_btultra:
	case ZSTD_btultra2:
	if (chunk >= HASH_READ_SIZE)
	ZSTD_updateTree(ms, ichunk-HASH_READ_SIZE, ichunk);
	break;

	default:
	assert(0); /* not possible : not a valid strategy id */
	}

	ip = ichunk;
	}

	ms->nextToUpdate = (U32)(iend - ms->window.base);
	return 0;
	}


	/* Dictionaries that assign zero probability to symbols that show up causes problems
	when FSE encoding. Refuse dictionaries that assign zero probability to symbols
	that we may encounter during compression.
	NOTE: This behavior is not standard and could be improved in the future. */
	static size_t ZSTD_checkDictNCount(short* normalizedCounter, unsigned dictMaxSymbolValue, unsigned maxSymbolValue) {
	U32 s;
	RETURN_ERROR_IF(dictMaxSymbolValue < maxSymbolValue, dictionary_corrupted, "dict fse tables don't have all symbols");
	for (s = 0; s <= maxSymbolValue; ++s) {
	RETURN_ERROR_IF(normalizedCounter[s] == 0, dictionary_corrupted, "dict fse tables don't have all symbols");
	}
	return 0;
	}

	size_t ZSTD_loadCEntropy(ZSTD_compressedBlockState_t* bs, void* workspace,
	short* offcodeNCount, unsigned* offcodeMaxValue,
	const void* const dict, size_t dictSize)
	{
	const BYTE* dictPtr = (const BYTE)dict; / skip magic num and dict ID */
	const BYTE* const dictEnd = dictPtr + dictSize;
	dictPtr += 8;
	bs->entropy.huf.repeatMode = HUF_repeat_check;

	{ unsigned maxSymbolValue = 255;
	unsigned hasZeroWeights = 1;
	size_t const hufHeaderSize = HUF_readCTable((HUF_CElt*)bs->entropy.huf.CTable, &maxSymbolValue, dictPtr,
	dictEnd-dictPtr, &hasZeroWeights);

	/* We only set the loaded table as valid if it contains all non-zero
	* weights. Otherwise, we set it to check */
	if (!hasZeroWeights)
	bs->entropy.huf.repeatMode = HUF_repeat_valid;

	RETURN_ERROR_IF(HUF_isError(hufHeaderSize), dictionary_corrupted, "");
	RETURN_ERROR_IF(maxSymbolValue < 255, dictionary_corrupted, "");
	dictPtr += hufHeaderSize;
	}

	{ unsigned offcodeLog;
	size_t const offcodeHeaderSize = FSE_readNCount(offcodeNCount, offcodeMaxValue, &offcodeLog, dictPtr, dictEnd-dictPtr);
	RETURN_ERROR_IF(FSE_isError(offcodeHeaderSize), dictionary_corrupted, "");
	RETURN_ERROR_IF(offcodeLog > OffFSELog, dictionary_corrupted, "");
	/* Defer checking offcodeMaxValue because we need to know the size of the dictionary content */
	/* fill all offset symbols to avoid garbage at end of table */
	RETURN_ERROR_IF(FSE_isError(FSE_buildCTable_wksp(
	bs->entropy.fse.offcodeCTable,
	offcodeNCount, MaxOff, offcodeLog,
	workspace, HUF_WORKSPACE_SIZE)),
	dictionary_corrupted, "");
	dictPtr += offcodeHeaderSize;
	}

	{ short matchlengthNCount[MaxML+1];
	unsigned matchlengthMaxValue = MaxML, matchlengthLog;
	size_t const matchlengthHeaderSize = FSE_readNCount(matchlengthNCount, &matchlengthMaxValue, &matchlengthLog, dictPtr, dictEnd-dictPtr);
	RETURN_ERROR_IF(FSE_isError(matchlengthHeaderSize), dictionary_corrupted, "");
	RETURN_ERROR_IF(matchlengthLog > MLFSELog, dictionary_corrupted, "");
	/* Every match length code must have non-zero probability */
	FORWARD_IF_ERROR( ZSTD_checkDictNCount(matchlengthNCount, matchlengthMaxValue, MaxML), "");
	RETURN_ERROR_IF(FSE_isError(FSE_buildCTable_wksp(
	bs->entropy.fse.matchlengthCTable,
	matchlengthNCount, matchlengthMaxValue, matchlengthLog,
	workspace, HUF_WORKSPACE_SIZE)),
	dictionary_corrupted, "");
	dictPtr += matchlengthHeaderSize;
	}

	{ short litlengthNCount[MaxLL+1];
	unsigned litlengthMaxValue = MaxLL, litlengthLog;
	size_t const litlengthHeaderSize = FSE_readNCount(litlengthNCount, &litlengthMaxValue, &litlengthLog, dictPtr, dictEnd-dictPtr);
	RETURN_ERROR_IF(FSE_isError(litlengthHeaderSize), dictionary_corrupted, "");
	RETURN_ERROR_IF(litlengthLog > LLFSELog, dictionary_corrupted, "");
	/* Every literal length code must have non-zero probability */
	FORWARD_IF_ERROR( ZSTD_checkDictNCount(litlengthNCount, litlengthMaxValue, MaxLL), "");
	RETURN_ERROR_IF(FSE_isError(FSE_buildCTable_wksp(
	bs->entropy.fse.litlengthCTable,
	litlengthNCount, litlengthMaxValue, litlengthLog,
	workspace, HUF_WORKSPACE_SIZE)),
	dictionary_corrupted, "");
	dictPtr += litlengthHeaderSize;
	}

	RETURN_ERROR_IF(dictPtr+12 > dictEnd, dictionary_corrupted, "");
	bs->rep[0] = MEM_readLE32(dictPtr+0);
	bs->rep[1] = MEM_readLE32(dictPtr+4);
	bs->rep[2] = MEM_readLE32(dictPtr+8);
	dictPtr += 12;

	return dictPtr - (const BYTE*)dict;
	}

	/* Dictionary format :
	* See :
	* https://github.com/facebook/zstd/blob/master/doc/zstd_compression_format.md#dictionary-format
	*/
	/*! ZSTD_loadZstdDictionary() :
	* @return : dictID, or an error code
	* assumptions : magic number supposed already checked
	* dictSize supposed >= 8
	*/
	static size_t ZSTD_loadZstdDictionary(ZSTD_compressedBlockState_t* bs,
	ZSTD_matchState_t* ms,
	ZSTD_cwksp* ws,
	ZSTD_CCtx_params const* params,
	const void* dict, size_t dictSize,
	ZSTD_dictTableLoadMethod_e dtlm,
	void* workspace)
	{
	const BYTE* dictPtr = (const BYTE*)dict;
	const BYTE* const dictEnd = dictPtr + dictSize;
	short offcodeNCount[MaxOff+1];
	unsigned offcodeMaxValue = MaxOff;
	size_t dictID;
	size_t eSize;

	ZSTD_STATIC_ASSERT(HUF_WORKSPACE_SIZE >= (1<<MAX(MLFSELog,LLFSELog)));
	assert(dictSize >= 8);
	assert(MEM_readLE32(dictPtr) == ZSTD_MAGIC_DICTIONARY);

	dictID = params->fParams.noDictIDFlag ? 0 : MEM_readLE32(dictPtr + 4 /* skip magic number */ );
	eSize = ZSTD_loadCEntropy(bs, workspace, offcodeNCount, &offcodeMaxValue, dict, dictSize);
	FORWARD_IF_ERROR(eSize, "ZSTD_loadCEntropy failed");
	dictPtr += eSize;

	{ size_t const dictContentSize = (size_t)(dictEnd - dictPtr);
	U32 offcodeMax = MaxOff;
	if (dictContentSize <= ((U32)-1) - 128 KB) {
	U32 const maxOffset = (U32)dictContentSize + 128 KB; /* The maximum offset that must be supported */
	offcodeMax = ZSTD_highbit32(maxOffset); /* Calculate minimum offset code required to represent maxOffset */
	}
	/* All offset values <= dictContentSize + 128 KB must be representable */
	FORWARD_IF_ERROR(ZSTD_checkDictNCount(offcodeNCount, offcodeMaxValue, MIN(offcodeMax, MaxOff)), "");
	/* All repCodes must be <= dictContentSize and != 0*/
	{ U32 u;
	for (u=0; u<3; u++) {
	RETURN_ERROR_IF(bs->rep[u] == 0, dictionary_corrupted, "");
	RETURN_ERROR_IF(bs->rep[u] > dictContentSize, dictionary_corrupted, "");
	} }

	bs->entropy.fse.offcode_repeatMode = FSE_repeat_valid;
	bs->entropy.fse.matchlength_repeatMode = FSE_repeat_valid;
	bs->entropy.fse.litlength_repeatMode = FSE_repeat_valid;
	FORWARD_IF_ERROR(ZSTD_loadDictionaryContent(
	ms, NULL, ws, params, dictPtr, dictContentSize, dtlm), "");
	return dictID;
	}
	}

	/** ZSTD_compress_insertDictionary() :
	* @return : dictID, or an error code */
	static size_t
	ZSTD_compress_insertDictionary(ZSTD_compressedBlockState_t* bs,
	ZSTD_matchState_t* ms,
	ldmState_t* ls,
	ZSTD_cwksp* ws,
	const ZSTD_CCtx_params* params,
	const void* dict, size_t dictSize,
	ZSTD_dictContentType_e dictContentType,
	ZSTD_dictTableLoadMethod_e dtlm,
	void* workspace)
	{
	DEBUGLOG(4, "ZSTD_compress_insertDictionary (dictSize=%u)", (U32)dictSize);
	if ((dict==NULL) \|\| (dictSize<8)) {
	RETURN_ERROR_IF(dictContentType == ZSTD_dct_fullDict, dictionary_wrong, "");
	return 0;
	}

	ZSTD_reset_compressedBlockState(bs);

	/* dict restricted modes */
	if (dictContentType == ZSTD_dct_rawContent)
	return ZSTD_loadDictionaryContent(ms, ls, ws, params, dict, dictSize, dtlm);

	if (MEM_readLE32(dict) != ZSTD_MAGIC_DICTIONARY) {
	if (dictContentType == ZSTD_dct_auto) {
	DEBUGLOG(4, "raw content dictionary detected");
	return ZSTD_loadDictionaryContent(
	ms, ls, ws, params, dict, dictSize, dtlm);
	}
	RETURN_ERROR_IF(dictContentType == ZSTD_dct_fullDict, dictionary_wrong, "");
	assert(0); /* impossible */
	}

	/* dict as full zstd dictionary */
	return ZSTD_loadZstdDictionary(
	bs, ms, ws, params, dict, dictSize, dtlm, workspace);
	}

	#define ZSTD_USE_CDICT_PARAMS_SRCSIZE_CUTOFF (128 KB)
	#define ZSTD_USE_CDICT_PARAMS_DICTSIZE_MULTIPLIER (6)

	/*! ZSTD_compressBegin_internal() :
	* @return : 0, or an error code */
	static size_t ZSTD_compressBegin_internal(ZSTD_CCtx* cctx,
	const void* dict, size_t dictSize,
	ZSTD_dictContentType_e dictContentType,
	ZSTD_dictTableLoadMethod_e dtlm,
	const ZSTD_CDict* cdict,
	const ZSTD_CCtx_params* params, U64 pledgedSrcSize,
	ZSTD_buffered_policy_e zbuff)
	{
	DEBUGLOG(4, "ZSTD_compressBegin_internal: wlog=%u", params->cParams.windowLog);
	/* params are supposed to be fully validated at this point */
	assert(!ZSTD_isError(ZSTD_checkCParams(params->cParams)));
	assert(!((dict) && (cdict))); /* either dict or cdict, not both */
	if ( (cdict)
	&& (cdict->dictContentSize > 0)
	&& ( pledgedSrcSize < ZSTD_USE_CDICT_PARAMS_SRCSIZE_CUTOFF
	\|\| pledgedSrcSize < cdict->dictContentSize * ZSTD_USE_CDICT_PARAMS_DICTSIZE_MULTIPLIER
	\|\| pledgedSrcSize == ZSTD_CONTENTSIZE_UNKNOWN
	\|\| cdict->compressionLevel == 0)
	&& (params->attachDictPref != ZSTD_dictForceLoad) ) {
	return ZSTD_resetCCtx_usingCDict(cctx, cdict, params, pledgedSrcSize, zbuff);
	}

	FORWARD_IF_ERROR( ZSTD_resetCCtx_internal(cctx, *params, pledgedSrcSize,
	ZSTDcrp_makeClean, zbuff) , "");
	{ size_t const dictID = cdict ?
	ZSTD_compress_insertDictionary(
	cctx->blockState.prevCBlock, &cctx->blockState.matchState,
	&cctx->ldmState, &cctx->workspace, &cctx->appliedParams, cdict->dictContent,
	cdict->dictContentSize, dictContentType, dtlm,
	cctx->entropyWorkspace)
	: ZSTD_compress_insertDictionary(
	cctx->blockState.prevCBlock, &cctx->blockState.matchState,
	&cctx->ldmState, &cctx->workspace, &cctx->appliedParams, dict, dictSize,
	dictContentType, dtlm, cctx->entropyWorkspace);
	FORWARD_IF_ERROR(dictID, "ZSTD_compress_insertDictionary failed");
	assert(dictID <= UINT_MAX);
	cctx->dictID = (U32)dictID;
	}
	return 0;
	}

	size_t ZSTD_compressBegin_advanced_internal(ZSTD_CCtx* cctx,
	const void* dict, size_t dictSize,
	ZSTD_dictContentType_e dictContentType,
	ZSTD_dictTableLoadMethod_e dtlm,
	const ZSTD_CDict* cdict,
	const ZSTD_CCtx_params* params,
	unsigned long long pledgedSrcSize)
	{
	DEBUGLOG(4, "ZSTD_compressBegin_advanced_internal: wlog=%u", params->cParams.windowLog);
	/* compression parameters verification and optimization */
	FORWARD_IF_ERROR( ZSTD_checkCParams(params->cParams) , "");
	return ZSTD_compressBegin_internal(cctx,
	dict, dictSize, dictContentType, dtlm,
	cdict,
	params, pledgedSrcSize,
	ZSTDb_not_buffered);
	}

	/*! ZSTD_compressBegin_advanced() :
	* @return : 0, or an error code */
	size_t ZSTD_compressBegin_advanced(ZSTD_CCtx* cctx,
	const void* dict, size_t dictSize,
	ZSTD_parameters params, unsigned long long pledgedSrcSize)
	{
	ZSTD_CCtx_params const cctxParams =
	ZSTD_assignParamsToCCtxParams(&cctx->requestedParams, &params);
	return ZSTD_compressBegin_advanced_internal(cctx,
	dict, dictSize, ZSTD_dct_auto, ZSTD_dtlm_fast,
	NULL /cdict/,
	&cctxParams, pledgedSrcSize);
	}

	size_t ZSTD_compressBegin_usingDict(ZSTD_CCtx* cctx, const void* dict, size_t dictSize, int compressionLevel)
	{
	ZSTD_parameters const params = ZSTD_getParams_internal(compressionLevel, ZSTD_CONTENTSIZE_UNKNOWN, dictSize);
	ZSTD_CCtx_params const cctxParams =
	ZSTD_assignParamsToCCtxParams(&cctx->requestedParams, &params);
	DEBUGLOG(4, "ZSTD_compressBegin_usingDict (dictSize=%u)", (unsigned)dictSize);
	return ZSTD_compressBegin_internal(cctx, dict, dictSize, ZSTD_dct_auto, ZSTD_dtlm_fast, NULL,
	&cctxParams, ZSTD_CONTENTSIZE_UNKNOWN, ZSTDb_not_buffered);
	}

	size_t ZSTD_compressBegin(ZSTD_CCtx* cctx, int compressionLevel)
	{
	return ZSTD_compressBegin_usingDict(cctx, NULL, 0, compressionLevel);
	}


	/*! ZSTD_writeEpilogue() :
	* Ends a frame.
	* @return : nb of bytes written into dst (or an error code) */
	static size_t ZSTD_writeEpilogue(ZSTD_CCtx* cctx, void* dst, size_t dstCapacity)
	{
	BYTE* const ostart = (BYTE*)dst;
	BYTE* op = ostart;
	size_t fhSize = 0;

	DEBUGLOG(4, "ZSTD_writeEpilogue");
	RETURN_ERROR_IF(cctx->stage == ZSTDcs_created, stage_wrong, "init missing");

	/* special case : empty frame */
	if (cctx->stage == ZSTDcs_init) {
	fhSize = ZSTD_writeFrameHeader(dst, dstCapacity, &cctx->appliedParams, 0, 0);
	FORWARD_IF_ERROR(fhSize, "ZSTD_writeFrameHeader failed");
	dstCapacity -= fhSize;
	op += fhSize;
	cctx->stage = ZSTDcs_ongoing;
	}

	if (cctx->stage != ZSTDcs_ending) {
	/* write one last empty block, make it the "last" block */
	U32 const cBlockHeader24 = 1 /* last block */ + (((U32)bt_raw)<<1) + 0;
	RETURN_ERROR_IF(dstCapacity<4, dstSize_tooSmall, "no room for epilogue");
	MEM_writeLE32(op, cBlockHeader24);
	op += ZSTD_blockHeaderSize;
	dstCapacity -= ZSTD_blockHeaderSize;
	}

	if (cctx->appliedParams.fParams.checksumFlag) {
	U32 const checksum = (U32) XXH64_digest(&cctx->xxhState);
	RETURN_ERROR_IF(dstCapacity<4, dstSize_tooSmall, "no room for checksum");
	DEBUGLOG(4, "ZSTD_writeEpilogue: write checksum : %08X", (unsigned)checksum);
	MEM_writeLE32(op, checksum);
	op += 4;
	}

	cctx->stage = ZSTDcs_created; /* return to "created but no init" status */
	return op-ostart;
	}

	size_t ZSTD_compressEnd (ZSTD_CCtx* cctx,
	void* dst, size_t dstCapacity,
	const void* src, size_t srcSize)
	{
	size_t endResult;
	size_t const cSize = ZSTD_compressContinue_internal(cctx,
	dst, dstCapacity, src, srcSize,
	1 /* frame mode /, 1 / last chunk */);
	FORWARD_IF_ERROR(cSize, "ZSTD_compressContinue_internal failed");
	endResult = ZSTD_writeEpilogue(cctx, (char*)dst + cSize, dstCapacity-cSize);
	FORWARD_IF_ERROR(endResult, "ZSTD_writeEpilogue failed");
	assert(!(cctx->appliedParams.fParams.contentSizeFlag && cctx->pledgedSrcSizePlusOne == 0));
	if (cctx->pledgedSrcSizePlusOne != 0) { /* control src size */
	ZSTD_STATIC_ASSERT(ZSTD_CONTENTSIZE_UNKNOWN == (unsigned long long)-1);
	DEBUGLOG(4, "end of frame : controlling src size");
	RETURN_ERROR_IF(
	cctx->pledgedSrcSizePlusOne != cctx->consumedSrcSize+1,
	srcSize_wrong,
	"error : pledgedSrcSize = %u, while realSrcSize = %u",
	(unsigned)cctx->pledgedSrcSizePlusOne-1,
	(unsigned)cctx->consumedSrcSize);
	}
	return cSize + endResult;
	}


	static size_t ZSTD_compress_internal (ZSTD_CCtx* cctx,
	void* dst, size_t dstCapacity,
	const void* src, size_t srcSize,
	const void* dict,size_t dictSize,
	const ZSTD_parameters* params)
	{
	ZSTD_CCtx_params const cctxParams =
	ZSTD_assignParamsToCCtxParams(&cctx->requestedParams, params);
	DEBUGLOG(4, "ZSTD_compress_internal");
	return ZSTD_compress_advanced_internal(cctx,
	dst, dstCapacity,
	src, srcSize,
	dict, dictSize,
	&cctxParams);
	}

	size_t ZSTD_compress_advanced (ZSTD_CCtx* cctx,
	void* dst, size_t dstCapacity,
	const void* src, size_t srcSize,
	const void* dict,size_t dictSize,
	ZSTD_parameters params)
	{
	DEBUGLOG(4, "ZSTD_compress_advanced");
	FORWARD_IF_ERROR(ZSTD_checkCParams(params.cParams), "");
	return ZSTD_compress_internal(cctx,
	dst, dstCapacity,
	src, srcSize,
	dict, dictSize,
	&params);
	}

	/* Internal */
	size_t ZSTD_compress_advanced_internal(
	ZSTD_CCtx* cctx,
	void* dst, size_t dstCapacity,
	const void* src, size_t srcSize,
	const void* dict,size_t dictSize,
	const ZSTD_CCtx_params* params)
	{
	DEBUGLOG(4, "ZSTD_compress_advanced_internal (srcSize:%u)", (unsigned)srcSize);
	FORWARD_IF_ERROR( ZSTD_compressBegin_internal(cctx,
	dict, dictSize, ZSTD_dct_auto, ZSTD_dtlm_fast, NULL,
	params, srcSize, ZSTDb_not_buffered) , "");
	return ZSTD_compressEnd(cctx, dst, dstCapacity, src, srcSize);
	}

	size_t ZSTD_compress_usingDict(ZSTD_CCtx* cctx,
	void* dst, size_t dstCapacity,
	const void* src, size_t srcSize,
	const void* dict, size_t dictSize,
	int compressionLevel)
	{
	ZSTD_parameters const params = ZSTD_getParams_internal(compressionLevel, srcSize, dict ? dictSize : 0);
	ZSTD_CCtx_params cctxParams = ZSTD_assignParamsToCCtxParams(&cctx->requestedParams, &params);
	DEBUGLOG(4, "ZSTD_compress_usingDict (srcSize=%u)", (unsigned)srcSize);
	assert(params.fParams.contentSizeFlag == 1);
	return ZSTD_compress_advanced_internal(cctx, dst, dstCapacity, src, srcSize, dict, dictSize, &cctxParams);
	}

	size_t ZSTD_compressCCtx(ZSTD_CCtx* cctx,
	void* dst, size_t dstCapacity,
	const void* src, size_t srcSize,
	int compressionLevel)
	{
	DEBUGLOG(4, "ZSTD_compressCCtx (srcSize=%u)", (unsigned)srcSize);
	assert(cctx != NULL);
	return ZSTD_compress_usingDict(cctx, dst, dstCapacity, src, srcSize, NULL, 0, compressionLevel);
	}

	size_t ZSTD_compress(void* dst, size_t dstCapacity,
	const void* src, size_t srcSize,
	int compressionLevel)
	{
	size_t result;
	ZSTD_CCtx ctxBody;
	ZSTD_initCCtx(&ctxBody, ZSTD_defaultCMem);
	result = ZSTD_compressCCtx(&ctxBody, dst, dstCapacity, src, srcSize, compressionLevel);
	ZSTD_freeCCtxContent(&ctxBody); /* can't free ctxBody itself, as it's on stack; free only heap content */
	return result;
	}


	/* ===== Dictionary API ===== */

	/*! ZSTD_estimateCDictSize_advanced() :
	* Estimate amount of memory that will be needed to create a dictionary with following arguments */
	size_t ZSTD_estimateCDictSize_advanced(
	size_t dictSize, ZSTD_compressionParameters cParams,
	ZSTD_dictLoadMethod_e dictLoadMethod)
	{
	DEBUGLOG(5, "sizeof(ZSTD_CDict) : %u", (unsigned)sizeof(ZSTD_CDict));
	return ZSTD_cwksp_alloc_size(sizeof(ZSTD_CDict))
	+ ZSTD_cwksp_alloc_size(HUF_WORKSPACE_SIZE)
	+ ZSTD_sizeof_matchState(&cParams, /* forCCtx */ 0)
	+ (dictLoadMethod == ZSTD_dlm_byRef ? 0
	: ZSTD_cwksp_alloc_size(ZSTD_cwksp_align(dictSize, sizeof(void *))));
	}

	size_t ZSTD_estimateCDictSize(size_t dictSize, int compressionLevel)
	{
	ZSTD_compressionParameters const cParams = ZSTD_getCParams_internal(compressionLevel, ZSTD_CONTENTSIZE_UNKNOWN, dictSize);
	return ZSTD_estimateCDictSize_advanced(dictSize, cParams, ZSTD_dlm_byCopy);
	}

	size_t ZSTD_sizeof_CDict(const ZSTD_CDict* cdict)
	{
	if (cdict==NULL) return 0; /* support sizeof on NULL */
	DEBUGLOG(5, "sizeof(cdict) : %u", (unsigned)sizeof(cdict));
	/* cdict may be in the workspace */
	return (cdict->workspace.workspace == cdict ? 0 : sizeof(*cdict))
	+ ZSTD_cwksp_sizeof(&cdict->workspace);
	}

	static size_t ZSTD_initCDict_internal(
	ZSTD_CDict* cdict,
	const void* dictBuffer, size_t dictSize,
	ZSTD_dictLoadMethod_e dictLoadMethod,
	ZSTD_dictContentType_e dictContentType,
	ZSTD_compressionParameters cParams)
	{
	DEBUGLOG(3, "ZSTD_initCDict_internal (dictContentType:%u)", (unsigned)dictContentType);
	assert(!ZSTD_checkCParams(cParams));
	cdict->matchState.cParams = cParams;
	if ((dictLoadMethod == ZSTD_dlm_byRef) \|\| (!dictBuffer) \|\| (!dictSize)) {
	cdict->dictContent = dictBuffer;
	} else {
	void internalBuffer = ZSTD_cwksp_reserve_object(&cdict->workspace, ZSTD_cwksp_align(dictSize, sizeof(void)));
	RETURN_ERROR_IF(!internalBuffer, memory_allocation, "NULL pointer!");
	cdict->dictContent = internalBuffer;
	memcpy(internalBuffer, dictBuffer, dictSize);
	}
	cdict->dictContentSize = dictSize;

	cdict->entropyWorkspace = (U32*)ZSTD_cwksp_reserve_object(&cdict->workspace, HUF_WORKSPACE_SIZE);


	/* Reset the state to no dictionary */
	ZSTD_reset_compressedBlockState(&cdict->cBlockState);
	FORWARD_IF_ERROR(ZSTD_reset_matchState(
	&cdict->matchState,
	&cdict->workspace,
	&cParams,
	ZSTDcrp_makeClean,
	ZSTDirp_reset,
	ZSTD_resetTarget_CDict), "");
	/* (Maybe) load the dictionary
	* Skips loading the dictionary if it is < 8 bytes.
	*/
	{ ZSTD_CCtx_params params;
	memset(&params, 0, sizeof(params));
	params.compressionLevel = ZSTD_CLEVEL_DEFAULT;
	params.fParams.contentSizeFlag = 1;
	params.cParams = cParams;
	{ size_t const dictID = ZSTD_compress_insertDictionary(
	&cdict->cBlockState, &cdict->matchState, NULL, &cdict->workspace,
	&params, cdict->dictContent, cdict->dictContentSize,
	dictContentType, ZSTD_dtlm_full, cdict->entropyWorkspace);
	FORWARD_IF_ERROR(dictID, "ZSTD_compress_insertDictionary failed");
	assert(dictID <= (size_t)(U32)-1);
	cdict->dictID = (U32)dictID;
	}
	}

	return 0;
	}

	ZSTD_CDict* ZSTD_createCDict_advanced(const void* dictBuffer, size_t dictSize,
	ZSTD_dictLoadMethod_e dictLoadMethod,
	ZSTD_dictContentType_e dictContentType,
	ZSTD_compressionParameters cParams, ZSTD_customMem customMem)
	{
	DEBUGLOG(3, "ZSTD_createCDict_advanced, mode %u", (unsigned)dictContentType);
	if (!customMem.customAlloc ^ !customMem.customFree) return NULL;

	{ size_t const workspaceSize =
	ZSTD_cwksp_alloc_size(sizeof(ZSTD_CDict)) +
	ZSTD_cwksp_alloc_size(HUF_WORKSPACE_SIZE) +
	ZSTD_sizeof_matchState(&cParams, /* forCCtx */ 0) +
	(dictLoadMethod == ZSTD_dlm_byRef ? 0
	: ZSTD_cwksp_alloc_size(ZSTD_cwksp_align(dictSize, sizeof(void*))));
	void* const workspace = ZSTD_malloc(workspaceSize, customMem);
	ZSTD_cwksp ws;
	ZSTD_CDict* cdict;

	if (!workspace) {
	ZSTD_free(workspace, customMem);
	return NULL;
	}

	ZSTD_cwksp_init(&ws, workspace, workspaceSize);

	cdict = (ZSTD_CDict*)ZSTD_cwksp_reserve_object(&ws, sizeof(ZSTD_CDict));
	assert(cdict != NULL);
	ZSTD_cwksp_move(&cdict->workspace, &ws);
	cdict->customMem = customMem;
	cdict->compressionLevel = 0; /* signals advanced API usage */

	if (ZSTD_isError( ZSTD_initCDict_internal(cdict,
	dictBuffer, dictSize,
	dictLoadMethod, dictContentType,
	cParams) )) {
	ZSTD_freeCDict(cdict);
	return NULL;
	}

	return cdict;
	}
	}

	ZSTD_CDict* ZSTD_createCDict(const void* dict, size_t dictSize, int compressionLevel)
	{
	ZSTD_compressionParameters cParams = ZSTD_getCParams_internal(compressionLevel, ZSTD_CONTENTSIZE_UNKNOWN, dictSize);
	ZSTD_CDict* cdict = ZSTD_createCDict_advanced(dict, dictSize,
	ZSTD_dlm_byCopy, ZSTD_dct_auto,
	cParams, ZSTD_defaultCMem);
	if (cdict)
	cdict->compressionLevel = compressionLevel == 0 ? ZSTD_CLEVEL_DEFAULT : compressionLevel;
	return cdict;
	}

	ZSTD_CDict* ZSTD_createCDict_byReference(const void* dict, size_t dictSize, int compressionLevel)
	{
	ZSTD_compressionParameters cParams = ZSTD_getCParams_internal(compressionLevel, ZSTD_CONTENTSIZE_UNKNOWN, dictSize);
	return ZSTD_createCDict_advanced(dict, dictSize,
	ZSTD_dlm_byRef, ZSTD_dct_auto,
	cParams, ZSTD_defaultCMem);
	}

	size_t ZSTD_freeCDict(ZSTD_CDict* cdict)
	{
	if (cdict==NULL) return 0; /* support free on NULL */
	{ ZSTD_customMem const cMem = cdict->customMem;
	int cdictInWorkspace = ZSTD_cwksp_owns_buffer(&cdict->workspace, cdict);
	ZSTD_cwksp_free(&cdict->workspace, cMem);
	if (!cdictInWorkspace) {
	ZSTD_free(cdict, cMem);
	}
	return 0;
	}
	}

	/*! ZSTD_initStaticCDict_advanced() :
	* Generate a digested dictionary in provided memory area.
	* workspace: The memory area to emplace the dictionary into.
	* Provided pointer must 8-bytes aligned.
	* It must outlive dictionary usage.
	* workspaceSize: Use ZSTD_estimateCDictSize()
	* to determine how large workspace must be.
	* cParams : use ZSTD_getCParams() to transform a compression level
	* into its relevants cParams.
	* @return : pointer to ZSTD_CDict*, or NULL if error (size too small)
	* Note : there is no corresponding "free" function.
	* Since workspace was allocated externally, it must be freed externally.
	*/
	const ZSTD_CDict* ZSTD_initStaticCDict(
	void* workspace, size_t workspaceSize,
	const void* dict, size_t dictSize,
	ZSTD_dictLoadMethod_e dictLoadMethod,
	ZSTD_dictContentType_e dictContentType,
	ZSTD_compressionParameters cParams)
	{
	size_t const matchStateSize = ZSTD_sizeof_matchState(&cParams, /* forCCtx */ 0);
	size_t const neededSize = ZSTD_cwksp_alloc_size(sizeof(ZSTD_CDict))
	+ (dictLoadMethod == ZSTD_dlm_byRef ? 0
	: ZSTD_cwksp_alloc_size(ZSTD_cwksp_align(dictSize, sizeof(void*))))
	+ ZSTD_cwksp_alloc_size(HUF_WORKSPACE_SIZE)
	+ matchStateSize;
	ZSTD_CDict* cdict;

	if ((size_t)workspace & 7) return NULL; /* 8-aligned */

	{
	ZSTD_cwksp ws;
	ZSTD_cwksp_init(&ws, workspace, workspaceSize);
	cdict = (ZSTD_CDict*)ZSTD_cwksp_reserve_object(&ws, sizeof(ZSTD_CDict));
	if (cdict == NULL) return NULL;
	ZSTD_cwksp_move(&cdict->workspace, &ws);
	}

	DEBUGLOG(4, "(workspaceSize < neededSize) : (%u < %u) => %u",
	(unsigned)workspaceSize, (unsigned)neededSize, (unsigned)(workspaceSize < neededSize));
	if (workspaceSize < neededSize) return NULL;

	if (ZSTD_isError( ZSTD_initCDict_internal(cdict,
	dict, dictSize,
	dictLoadMethod, dictContentType,
	cParams) ))
	return NULL;

	return cdict;
	}

	ZSTD_compressionParameters ZSTD_getCParamsFromCDict(const ZSTD_CDict* cdict)
	{
	assert(cdict != NULL);
	return cdict->matchState.cParams;
	}

	/* ZSTD_compressBegin_usingCDict_advanced() :
	* cdict must be != NULL */
	size_t ZSTD_compressBegin_usingCDict_advanced(
	ZSTD_CCtx* const cctx, const ZSTD_CDict* const cdict,
	ZSTD_frameParameters const fParams, unsigned long long const pledgedSrcSize)
	{
	DEBUGLOG(4, "ZSTD_compressBegin_usingCDict_advanced");
	RETURN_ERROR_IF(cdict==NULL, dictionary_wrong, "NULL pointer!");
	{ ZSTD_CCtx_params params = cctx->requestedParams;
	params.cParams = ( pledgedSrcSize < ZSTD_USE_CDICT_PARAMS_SRCSIZE_CUTOFF
	\|\| pledgedSrcSize < cdict->dictContentSize * ZSTD_USE_CDICT_PARAMS_DICTSIZE_MULTIPLIER
	\|\| pledgedSrcSize == ZSTD_CONTENTSIZE_UNKNOWN
	\|\| cdict->compressionLevel == 0 )
	&& (params.attachDictPref != ZSTD_dictForceLoad) ?
	ZSTD_getCParamsFromCDict(cdict)
	: ZSTD_getCParams(cdict->compressionLevel,
	pledgedSrcSize,
	cdict->dictContentSize);
	/* Increase window log to fit the entire dictionary and source if the
	* source size is known. Limit the increase to 19, which is the
	* window log for compression level 1 with the largest source size.
	*/
	if (pledgedSrcSize != ZSTD_CONTENTSIZE_UNKNOWN) {
	U32 const limitedSrcSize = (U32)MIN(pledgedSrcSize, 1U << 19);
	U32 const limitedSrcLog = limitedSrcSize > 1 ? ZSTD_highbit32(limitedSrcSize - 1) + 1 : 1;
	params.cParams.windowLog = MAX(params.cParams.windowLog, limitedSrcLog);
	}
	params.fParams = fParams;
	return ZSTD_compressBegin_internal(cctx,
	NULL, 0, ZSTD_dct_auto, ZSTD_dtlm_fast,
	cdict,
	&params, pledgedSrcSize,
	ZSTDb_not_buffered);
	}
	}

	/* ZSTD_compressBegin_usingCDict() :
	* pledgedSrcSize=0 means "unknown"
	* if pledgedSrcSize>0, it will enable contentSizeFlag */
	size_t ZSTD_compressBegin_usingCDict(ZSTD_CCtx* cctx, const ZSTD_CDict* cdict)
	{
	ZSTD_frameParameters const fParams = { 0 /content/, 0 /checksum/, 0 /noDictID/ };
	DEBUGLOG(4, "ZSTD_compressBegin_usingCDict : dictIDFlag == %u", !fParams.noDictIDFlag);
	return ZSTD_compressBegin_usingCDict_advanced(cctx, cdict, fParams, ZSTD_CONTENTSIZE_UNKNOWN);
	}

	size_t ZSTD_compress_usingCDict_advanced(ZSTD_CCtx* cctx,
	void* dst, size_t dstCapacity,
	const void* src, size_t srcSize,
	const ZSTD_CDict* cdict, ZSTD_frameParameters fParams)
	{
	FORWARD_IF_ERROR(ZSTD_compressBegin_usingCDict_advanced(cctx, cdict, fParams, srcSize), ""); /* will check if cdict != NULL */
	return ZSTD_compressEnd(cctx, dst, dstCapacity, src, srcSize);
	}

	/*! ZSTD_compress_usingCDict() :
	* Compression using a digested Dictionary.
	* Faster startup than ZSTD_compress_usingDict(), recommended when same dictionary is used multiple times.
	* Note that compression parameters are decided at CDict creation time
	* while frame parameters are hardcoded */
	size_t ZSTD_compress_usingCDict(ZSTD_CCtx* cctx,
	void* dst, size_t dstCapacity,
	const void* src, size_t srcSize,
	const ZSTD_CDict* cdict)
	{
	ZSTD_frameParameters const fParams = { 1 /content/, 0 /checksum/, 0 /noDictID/ };
	return ZSTD_compress_usingCDict_advanced(cctx, dst, dstCapacity, src, srcSize, cdict, fParams);
	}



	/* ******************************************************************
	* Streaming
	********************************************************************/

	ZSTD_CStream* ZSTD_createCStream(void)
	{
	DEBUGLOG(3, "ZSTD_createCStream");
	return ZSTD_createCStream_advanced(ZSTD_defaultCMem);
	}

	ZSTD_CStream* ZSTD_initStaticCStream(void *workspace, size_t workspaceSize)
	{
	return ZSTD_initStaticCCtx(workspace, workspaceSize);
	}

	ZSTD_CStream* ZSTD_createCStream_advanced(ZSTD_customMem customMem)
	{ /* CStream and CCtx are now same object */
	return ZSTD_createCCtx_advanced(customMem);
	}

	size_t ZSTD_freeCStream(ZSTD_CStream* zcs)
	{
	return ZSTD_freeCCtx(zcs); /* same object */
	}



	/====== Initialization ======/

	size_t ZSTD_CStreamInSize(void) { return ZSTD_BLOCKSIZE_MAX; }

	size_t ZSTD_CStreamOutSize(void)
	{
	return ZSTD_compressBound(ZSTD_BLOCKSIZE_MAX) + ZSTD_blockHeaderSize + 4 /* 32-bits hash */ ;
	}

	static size_t ZSTD_resetCStream_internal(ZSTD_CStream* cctx,
	const void* const dict, size_t const dictSize, ZSTD_dictContentType_e const dictContentType,
	const ZSTD_CDict* const cdict,
	ZSTD_CCtx_params params, unsigned long long const pledgedSrcSize)
	{
	DEBUGLOG(4, "ZSTD_resetCStream_internal");
	/* Finalize the compression parameters */
	params.cParams = ZSTD_getCParamsFromCCtxParams(&params, pledgedSrcSize, dictSize);
	/* params are supposed to be fully validated at this point */
	assert(!ZSTD_isError(ZSTD_checkCParams(params.cParams)));
	assert(!((dict) && (cdict))); /* either dict or cdict, not both */

	FORWARD_IF_ERROR( ZSTD_compressBegin_internal(cctx,
	dict, dictSize, dictContentType, ZSTD_dtlm_fast,
	cdict,
	&params, pledgedSrcSize,
	ZSTDb_buffered) , "");

	cctx->inToCompress = 0;
	cctx->inBuffPos = 0;
	cctx->inBuffTarget = cctx->blockSize
	+ (cctx->blockSize == pledgedSrcSize); /* for small input: avoid automatic flush on reaching end of block, since it would require to add a 3-bytes null block to end frame */
	cctx->outBuffContentSize = cctx->outBuffFlushedSize = 0;
	cctx->streamStage = zcss_load;
	cctx->frameEnded = 0;
	return 0; /* ready to go */
	}

	/* ZSTD_resetCStream():
	* pledgedSrcSize == 0 means "unknown" */
	size_t ZSTD_resetCStream(ZSTD_CStream* zcs, unsigned long long pss)
	{
	/* temporary : 0 interpreted as "unknown" during transition period.
	* Users willing to specify "unknown" must use ZSTD_CONTENTSIZE_UNKNOWN.
	* 0 will be interpreted as "empty" in the future.
	*/
	U64 const pledgedSrcSize = (pss==0) ? ZSTD_CONTENTSIZE_UNKNOWN : pss;
	DEBUGLOG(4, "ZSTD_resetCStream: pledgedSrcSize = %u", (unsigned)pledgedSrcSize);
	FORWARD_IF_ERROR( ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only) , "");
	FORWARD_IF_ERROR( ZSTD_CCtx_setPledgedSrcSize(zcs, pledgedSrcSize) , "");
	return 0;
	}

	/*! ZSTD_initCStream_internal() :
	* Note : for lib/compress only. Used by zstdmt_compress.c.
	* Assumption 1 : params are valid
	* Assumption 2 : either dict, or cdict, is defined, not both */
	size_t ZSTD_initCStream_internal(ZSTD_CStream* zcs,
	const void* dict, size_t dictSize, const ZSTD_CDict* cdict,
	const ZSTD_CCtx_params* params,
	unsigned long long pledgedSrcSize)
	{
	DEBUGLOG(4, "ZSTD_initCStream_internal");
	FORWARD_IF_ERROR( ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only) , "");
	FORWARD_IF_ERROR( ZSTD_CCtx_setPledgedSrcSize(zcs, pledgedSrcSize) , "");
	assert(!ZSTD_isError(ZSTD_checkCParams(params->cParams)));
	zcs->requestedParams = *params;
	assert(!((dict) && (cdict))); /* either dict or cdict, not both */
	if (dict) {
	FORWARD_IF_ERROR( ZSTD_CCtx_loadDictionary(zcs, dict, dictSize) , "");
	} else {
	/* Dictionary is cleared if !cdict */
	FORWARD_IF_ERROR( ZSTD_CCtx_refCDict(zcs, cdict) , "");
	}
	return 0;
	}

	/* ZSTD_initCStream_usingCDict_advanced() :
	* same as ZSTD_initCStream_usingCDict(), with control over frame parameters */
	size_t ZSTD_initCStream_usingCDict_advanced(ZSTD_CStream* zcs,
	const ZSTD_CDict* cdict,
	ZSTD_frameParameters fParams,
	unsigned long long pledgedSrcSize)
	{
	DEBUGLOG(4, "ZSTD_initCStream_usingCDict_advanced");
	FORWARD_IF_ERROR( ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only) , "");
	FORWARD_IF_ERROR( ZSTD_CCtx_setPledgedSrcSize(zcs, pledgedSrcSize) , "");
	zcs->requestedParams.fParams = fParams;
	FORWARD_IF_ERROR( ZSTD_CCtx_refCDict(zcs, cdict) , "");
	return 0;
	}

	/* note : cdict must outlive compression session */
	size_t ZSTD_initCStream_usingCDict(ZSTD_CStream* zcs, const ZSTD_CDict* cdict)
	{
	DEBUGLOG(4, "ZSTD_initCStream_usingCDict");
	FORWARD_IF_ERROR( ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only) , "");
	FORWARD_IF_ERROR( ZSTD_CCtx_refCDict(zcs, cdict) , "");
	return 0;
	}


	/* ZSTD_initCStream_advanced() :
	* pledgedSrcSize must be exact.
	* if srcSize is not known at init time, use value ZSTD_CONTENTSIZE_UNKNOWN.
	* dict is loaded with default parameters ZSTD_dct_auto and ZSTD_dlm_byCopy. */
	size_t ZSTD_initCStream_advanced(ZSTD_CStream* zcs,
	const void* dict, size_t dictSize,
	ZSTD_parameters params, unsigned long long pss)
	{
	/* for compatibility with older programs relying on this behavior.
	* Users should now specify ZSTD_CONTENTSIZE_UNKNOWN.
	* This line will be removed in the future.
	*/
	U64 const pledgedSrcSize = (pss==0 && params.fParams.contentSizeFlag==0) ? ZSTD_CONTENTSIZE_UNKNOWN : pss;
	DEBUGLOG(4, "ZSTD_initCStream_advanced");
	FORWARD_IF_ERROR( ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only) , "");
	FORWARD_IF_ERROR( ZSTD_CCtx_setPledgedSrcSize(zcs, pledgedSrcSize) , "");
	FORWARD_IF_ERROR( ZSTD_checkCParams(params.cParams) , "");
	zcs->requestedParams = ZSTD_assignParamsToCCtxParams(&zcs->requestedParams, &params);
	FORWARD_IF_ERROR( ZSTD_CCtx_loadDictionary(zcs, dict, dictSize) , "");
	return 0;
	}

	size_t ZSTD_initCStream_usingDict(ZSTD_CStream* zcs, const void* dict, size_t dictSize, int compressionLevel)
	{
	DEBUGLOG(4, "ZSTD_initCStream_usingDict");
	FORWARD_IF_ERROR( ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only) , "");
	FORWARD_IF_ERROR( ZSTD_CCtx_setParameter(zcs, ZSTD_c_compressionLevel, compressionLevel) , "");
	FORWARD_IF_ERROR( ZSTD_CCtx_loadDictionary(zcs, dict, dictSize) , "");
	return 0;
	}

	size_t ZSTD_initCStream_srcSize(ZSTD_CStream* zcs, int compressionLevel, unsigned long long pss)
	{
	/* temporary : 0 interpreted as "unknown" during transition period.
	* Users willing to specify "unknown" must use ZSTD_CONTENTSIZE_UNKNOWN.
	* 0 will be interpreted as "empty" in the future.
	*/
	U64 const pledgedSrcSize = (pss==0) ? ZSTD_CONTENTSIZE_UNKNOWN : pss;
	DEBUGLOG(4, "ZSTD_initCStream_srcSize");
	FORWARD_IF_ERROR( ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only) , "");
	FORWARD_IF_ERROR( ZSTD_CCtx_refCDict(zcs, NULL) , "");
	FORWARD_IF_ERROR( ZSTD_CCtx_setParameter(zcs, ZSTD_c_compressionLevel, compressionLevel) , "");
	FORWARD_IF_ERROR( ZSTD_CCtx_setPledgedSrcSize(zcs, pledgedSrcSize) , "");
	return 0;
	}

	size_t ZSTD_initCStream(ZSTD_CStream* zcs, int compressionLevel)
	{
	DEBUGLOG(4, "ZSTD_initCStream");
	FORWARD_IF_ERROR( ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only) , "");
	FORWARD_IF_ERROR( ZSTD_CCtx_refCDict(zcs, NULL) , "");
	FORWARD_IF_ERROR( ZSTD_CCtx_setParameter(zcs, ZSTD_c_compressionLevel, compressionLevel) , "");
	return 0;
	}

	/====== Compression ======/

	static size_t ZSTD_nextInputSizeHint(const ZSTD_CCtx* cctx)
	{
	size_t hintInSize = cctx->inBuffTarget - cctx->inBuffPos;
	if (hintInSize==0) hintInSize = cctx->blockSize;
	return hintInSize;
	}

	/** ZSTD_compressStream_generic():
	* internal function for all compressStream() variants
	* non-static, because can be called from zstdmt_compress.c
	* @return : hint size for next input */
	static size_t ZSTD_compressStream_generic(ZSTD_CStream* zcs,
	ZSTD_outBuffer* output,
	ZSTD_inBuffer* input,
	ZSTD_EndDirective const flushMode)
	{
	const char* const istart = (const char*)input->src;
	const char* const iend = input->size != 0 ? istart + input->size : istart;
	const char* ip = input->pos != 0 ? istart + input->pos : istart;
	char* const ostart = (char*)output->dst;
	char* const oend = output->size != 0 ? ostart + output->size : ostart;
	char* op = output->pos != 0 ? ostart + output->pos : ostart;
	U32 someMoreWork = 1;

	/* check expectations */
	DEBUGLOG(5, "ZSTD_compressStream_generic, flush=%u", (unsigned)flushMode);
	assert(zcs->inBuff != NULL);
	assert(zcs->inBuffSize > 0);
	assert(zcs->outBuff != NULL);
	assert(zcs->outBuffSize > 0);
	assert(output->pos <= output->size);
	assert(input->pos <= input->size);

	while (someMoreWork) {
	switch(zcs->streamStage)
	{
	case zcss_init:
	RETURN_ERROR(init_missing, "call ZSTD_initCStream() first!");

	case zcss_load:
	if ( (flushMode == ZSTD_e_end)
	&& ((size_t)(oend-op) >= ZSTD_compressBound(iend-ip)) /* enough dstCapacity */
	&& (zcs->inBuffPos == 0) ) {
	/* shortcut to compression pass directly into output buffer */
	size_t const cSize = ZSTD_compressEnd(zcs,
	op, oend-op, ip, iend-ip);
	DEBUGLOG(4, "ZSTD_compressEnd : cSize=%u", (unsigned)cSize);
	FORWARD_IF_ERROR(cSize, "ZSTD_compressEnd failed");
	ip = iend;
	op += cSize;
	zcs->frameEnded = 1;
	ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);
	someMoreWork = 0; break;
	}
	/* complete loading into inBuffer */
	{ size_t const toLoad = zcs->inBuffTarget - zcs->inBuffPos;
	size_t const loaded = ZSTD_limitCopy(
	zcs->inBuff + zcs->inBuffPos, toLoad,
	ip, iend-ip);
	zcs->inBuffPos += loaded;
	if (loaded != 0)
	ip += loaded;
	if ( (flushMode == ZSTD_e_continue)
	&& (zcs->inBuffPos < zcs->inBuffTarget) ) {
	/* not enough input to fill full block : stop here */
	someMoreWork = 0; break;
	}
	if ( (flushMode == ZSTD_e_flush)
	&& (zcs->inBuffPos == zcs->inToCompress) ) {
	/* empty */
	someMoreWork = 0; break;
	}
	}
	/* compress current block (note : this stage cannot be stopped in the middle) */
	DEBUGLOG(5, "stream compression stage (flushMode==%u)", flushMode);
	{ void* cDst;
	size_t cSize;
	size_t const iSize = zcs->inBuffPos - zcs->inToCompress;
	size_t oSize = oend-op;
	unsigned const lastBlock = (flushMode == ZSTD_e_end) && (ip==iend);
	if (oSize >= ZSTD_compressBound(iSize))
	cDst = op; /* compress into output buffer, to skip flush stage */
	else
	cDst = zcs->outBuff, oSize = zcs->outBuffSize;
	cSize = lastBlock ?
	ZSTD_compressEnd(zcs, cDst, oSize,
	zcs->inBuff + zcs->inToCompress, iSize) :
	ZSTD_compressContinue(zcs, cDst, oSize,
	zcs->inBuff + zcs->inToCompress, iSize);
	FORWARD_IF_ERROR(cSize, "%s", lastBlock ? "ZSTD_compressEnd failed" : "ZSTD_compressContinue failed");
	zcs->frameEnded = lastBlock;
	/* prepare next block */
	zcs->inBuffTarget = zcs->inBuffPos + zcs->blockSize;
	if (zcs->inBuffTarget > zcs->inBuffSize)
	zcs->inBuffPos = 0, zcs->inBuffTarget = zcs->blockSize;
	DEBUGLOG(5, "inBuffTarget:%u / inBuffSize:%u",
	(unsigned)zcs->inBuffTarget, (unsigned)zcs->inBuffSize);
	if (!lastBlock)
	assert(zcs->inBuffTarget <= zcs->inBuffSize);
	zcs->inToCompress = zcs->inBuffPos;
	if (cDst == op) { /* no need to flush */
	op += cSize;
	if (zcs->frameEnded) {
	DEBUGLOG(5, "Frame completed directly in outBuffer");
	someMoreWork = 0;
	ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);
	}
	break;
	}
	zcs->outBuffContentSize = cSize;
	zcs->outBuffFlushedSize = 0;
	zcs->streamStage = zcss_flush; /* pass-through to flush stage */
	}
	/* fall-through */
	case zcss_flush:
	DEBUGLOG(5, "flush stage");
	{ size_t const toFlush = zcs->outBuffContentSize - zcs->outBuffFlushedSize;
	size_t const flushed = ZSTD_limitCopy(op, (size_t)(oend-op),
	zcs->outBuff + zcs->outBuffFlushedSize, toFlush);
	DEBUGLOG(5, "toFlush: %u into %u ==> flushed: %u",
	(unsigned)toFlush, (unsigned)(oend-op), (unsigned)flushed);
	if (flushed)
	op += flushed;
	zcs->outBuffFlushedSize += flushed;
	if (toFlush!=flushed) {
	/* flush not fully completed, presumably because dst is too small */
	assert(op==oend);
	someMoreWork = 0;
	break;
	}
	zcs->outBuffContentSize = zcs->outBuffFlushedSize = 0;
	if (zcs->frameEnded) {
	DEBUGLOG(5, "Frame completed on flush");
	someMoreWork = 0;
	ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);
	break;
	}
	zcs->streamStage = zcss_load;
	break;
	}

	default: /* impossible */
	assert(0);
	}
	}

	input->pos = ip - istart;
	output->pos = op - ostart;
	if (zcs->frameEnded) return 0;
	return ZSTD_nextInputSizeHint(zcs);
	}

	static size_t ZSTD_nextInputSizeHint_MTorST(const ZSTD_CCtx* cctx)
	{
	#ifdef ZSTD_MULTITHREAD
	if (cctx->appliedParams.nbWorkers >= 1) {
	assert(cctx->mtctx != NULL);
	return ZSTDMT_nextInputSizeHint(cctx->mtctx);
	}
	#endif
	return ZSTD_nextInputSizeHint(cctx);

	}

	size_t ZSTD_compressStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output, ZSTD_inBuffer* input)
	{
	FORWARD_IF_ERROR( ZSTD_compressStream2(zcs, output, input, ZSTD_e_continue) , "");
	return ZSTD_nextInputSizeHint_MTorST(zcs);
	}


	size_t ZSTD_compressStream2( ZSTD_CCtx* cctx,
	ZSTD_outBuffer* output,
	ZSTD_inBuffer* input,
	ZSTD_EndDirective endOp)
	{
	DEBUGLOG(5, "ZSTD_compressStream2, endOp=%u ", (unsigned)endOp);
	/* check conditions */
	RETURN_ERROR_IF(output->pos > output->size, GENERIC, "invalid buffer");
	RETURN_ERROR_IF(input->pos > input->size, GENERIC, "invalid buffer");
	assert(cctx!=NULL);

	/* transparent initialization stage */
	if (cctx->streamStage == zcss_init) {
	ZSTD_CCtx_params params = cctx->requestedParams;
	ZSTD_prefixDict const prefixDict = cctx->prefixDict;
	FORWARD_IF_ERROR( ZSTD_initLocalDict(cctx) , ""); /* Init the local dict if present. */
	memset(&cctx->prefixDict, 0, sizeof(cctx->prefixDict)); /* single usage */
	assert(prefixDict.dict==NULL \|\| cctx->cdict==NULL); /* only one can be set */
	DEBUGLOG(4, "ZSTD_compressStream2 : transparent init stage");
	if (endOp == ZSTD_e_end) cctx->pledgedSrcSizePlusOne = input->size + 1; /* auto-fix pledgedSrcSize */
	params.cParams = ZSTD_getCParamsFromCCtxParams(
	&cctx->requestedParams, cctx->pledgedSrcSizePlusOne-1, 0 /dictSize/);


	#ifdef ZSTD_MULTITHREAD
	if ((cctx->pledgedSrcSizePlusOne-1) <= ZSTDMT_JOBSIZE_MIN) {
	params.nbWorkers = 0; /* do not invoke multi-threading when src size is too small */
	}
	if (params.nbWorkers > 0) {
	/* mt context creation */
	if (cctx->mtctx == NULL) {
	DEBUGLOG(4, "ZSTD_compressStream2: creating new mtctx for nbWorkers=%u",
	params.nbWorkers);
	cctx->mtctx = ZSTDMT_createCCtx_advanced((U32)params.nbWorkers, cctx->customMem);
	RETURN_ERROR_IF(cctx->mtctx == NULL, memory_allocation, "NULL pointer!");
	}
	/* mt compression */
	DEBUGLOG(4, "call ZSTDMT_initCStream_internal as nbWorkers=%u", params.nbWorkers);
	FORWARD_IF_ERROR( ZSTDMT_initCStream_internal(
	cctx->mtctx,
	prefixDict.dict, prefixDict.dictSize, prefixDict.dictContentType,
	cctx->cdict, params, cctx->pledgedSrcSizePlusOne-1) , "");
	cctx->streamStage = zcss_load;
	cctx->appliedParams.nbWorkers = params.nbWorkers;
	} else
	#endif
	{ FORWARD_IF_ERROR( ZSTD_resetCStream_internal(cctx,
	prefixDict.dict, prefixDict.dictSize, prefixDict.dictContentType,
	cctx->cdict,
	params, cctx->pledgedSrcSizePlusOne-1) , "");
	assert(cctx->streamStage == zcss_load);
	assert(cctx->appliedParams.nbWorkers == 0);
	} }
	/* end of transparent initialization stage */

	/* compression stage */
	#ifdef ZSTD_MULTITHREAD
	if (cctx->appliedParams.nbWorkers > 0) {
	int const forceMaxProgress = (endOp == ZSTD_e_flush \|\| endOp == ZSTD_e_end);
	size_t flushMin;
	assert(forceMaxProgress \|\| endOp == ZSTD_e_continue /* Protection for a new flush type */);
	if (cctx->cParamsChanged) {
	ZSTDMT_updateCParams_whileCompressing(cctx->mtctx, &cctx->requestedParams);
	cctx->cParamsChanged = 0;
	}
	do {
	flushMin = ZSTDMT_compressStream_generic(cctx->mtctx, output, input, endOp);
	if ( ZSTD_isError(flushMin)
	\|\| (endOp == ZSTD_e_end && flushMin == 0) ) { /* compression completed */
	ZSTD_CCtx_reset(cctx, ZSTD_reset_session_only);
	}
	FORWARD_IF_ERROR(flushMin, "ZSTDMT_compressStream_generic failed");
	} while (forceMaxProgress && flushMin != 0 && output->pos < output->size);
	DEBUGLOG(5, "completed ZSTD_compressStream2 delegating to ZSTDMT_compressStream_generic");
	/* Either we don't require maximum forward progress, we've finished the
	* flush, or we are out of output space.
	*/
	assert(!forceMaxProgress \|\| flushMin == 0 \|\| output->pos == output->size);
	return flushMin;
	}
	#endif
	FORWARD_IF_ERROR( ZSTD_compressStream_generic(cctx, output, input, endOp) , "");
	DEBUGLOG(5, "completed ZSTD_compressStream2");
	return cctx->outBuffContentSize - cctx->outBuffFlushedSize; /* remaining to flush */
	}

	size_t ZSTD_compressStream2_simpleArgs (
	ZSTD_CCtx* cctx,
	void* dst, size_t dstCapacity, size_t* dstPos,
	const void* src, size_t srcSize, size_t* srcPos,
	ZSTD_EndDirective endOp)
	{
	ZSTD_outBuffer output = { dst, dstCapacity, *dstPos };
	ZSTD_inBuffer input = { src, srcSize, *srcPos };
	/* ZSTD_compressStream2() will check validity of dstPos and srcPos */
	size_t const cErr = ZSTD_compressStream2(cctx, &output, &input, endOp);
	*dstPos = output.pos;
	*srcPos = input.pos;
	return cErr;
	}

	size_t ZSTD_compress2(ZSTD_CCtx* cctx,
	void* dst, size_t dstCapacity,
	const void* src, size_t srcSize)
	{
	DEBUGLOG(4, "ZSTD_compress2 (srcSize=%u)", (unsigned)srcSize);
	ZSTD_CCtx_reset(cctx, ZSTD_reset_session_only);
	{ size_t oPos = 0;
	size_t iPos = 0;
	size_t const result = ZSTD_compressStream2_simpleArgs(cctx,
	dst, dstCapacity, &oPos,
	src, srcSize, &iPos,
	ZSTD_e_end);
	FORWARD_IF_ERROR(result, "ZSTD_compressStream2_simpleArgs failed");
	if (result != 0) { /* compression not completed, due to lack of output space */
	assert(oPos == dstCapacity);
	RETURN_ERROR(dstSize_tooSmall, "");
	}
	assert(iPos == srcSize); /* all input is expected consumed */
	return oPos;
	}
	}

	/====== Finalize ======/

	/*! ZSTD_flushStream() :
	* @return : amount of data remaining to flush */
	size_t ZSTD_flushStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output)
	{
	ZSTD_inBuffer input = { NULL, 0, 0 };
	return ZSTD_compressStream2(zcs, output, &input, ZSTD_e_flush);
	}


	size_t ZSTD_endStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output)
	{
	ZSTD_inBuffer input = { NULL, 0, 0 };
	size_t const remainingToFlush = ZSTD_compressStream2(zcs, output, &input, ZSTD_e_end);
	FORWARD_IF_ERROR( remainingToFlush , "ZSTD_compressStream2 failed");
	if (zcs->appliedParams.nbWorkers > 0) return remainingToFlush; /* minimal estimation */
	/* single thread mode : attempt to calculate remaining to flush more precisely */
	{ size_t const lastBlockSize = zcs->frameEnded ? 0 : ZSTD_BLOCKHEADERSIZE;
	size_t const checksumSize = (size_t)(zcs->frameEnded ? 0 : zcs->appliedParams.fParams.checksumFlag * 4);
	size_t const toFlush = remainingToFlush + lastBlockSize + checksumSize;
	DEBUGLOG(4, "ZSTD_endStream : remaining to flush : %u", (unsigned)toFlush);
	return toFlush;
	}
	}


	/-===== Pre-defined compression levels =====-/

	#define ZSTD_MAX_CLEVEL 22
	int ZSTD_maxCLevel(void) { return ZSTD_MAX_CLEVEL; }
	int ZSTD_minCLevel(void) { return (int)-ZSTD_TARGETLENGTH_MAX; }

	static const ZSTD_compressionParameters ZSTD_defaultCParameters[4][ZSTD_MAX_CLEVEL+1] = {
	{ /* "default" - for any srcSize > 256 KB */
	/* W, C, H, S, L, TL, strat */
	{ 19, 12, 13, 1, 6, 1, ZSTD_fast }, /* base for negative levels */
	{ 19, 13, 14, 1, 7, 0, ZSTD_fast }, /* level 1 */
	{ 20, 15, 16, 1, 6, 0, ZSTD_fast }, /* level 2 */
	{ 21, 16, 17, 1, 5, 0, ZSTD_dfast }, /* level 3 */
	{ 21, 18, 18, 1, 5, 0, ZSTD_dfast }, /* level 4 */
	{ 21, 18, 19, 2, 5, 2, ZSTD_greedy }, /* level 5 */
	{ 21, 19, 19, 3, 5, 4, ZSTD_greedy }, /* level 6 */
	{ 21, 19, 19, 3, 5, 8, ZSTD_lazy }, /* level 7 */
	{ 21, 19, 19, 3, 5, 16, ZSTD_lazy2 }, /* level 8 */
	{ 21, 19, 20, 4, 5, 16, ZSTD_lazy2 }, /* level 9 */
	{ 22, 20, 21, 4, 5, 16, ZSTD_lazy2 }, /* level 10 */
	{ 22, 21, 22, 4, 5, 16, ZSTD_lazy2 }, /* level 11 */
	{ 22, 21, 22, 5, 5, 16, ZSTD_lazy2 }, /* level 12 */
	{ 22, 21, 22, 5, 5, 32, ZSTD_btlazy2 }, /* level 13 */
	{ 22, 22, 23, 5, 5, 32, ZSTD_btlazy2 }, /* level 14 */
	{ 22, 23, 23, 6, 5, 32, ZSTD_btlazy2 }, /* level 15 */
	{ 22, 22, 22, 5, 5, 48, ZSTD_btopt }, /* level 16 */
	{ 23, 23, 22, 5, 4, 64, ZSTD_btopt }, /* level 17 */
	{ 23, 23, 22, 6, 3, 64, ZSTD_btultra }, /* level 18 */
	{ 23, 24, 22, 7, 3,256, ZSTD_btultra2}, /* level 19 */
	{ 25, 25, 23, 7, 3,256, ZSTD_btultra2}, /* level 20 */
	{ 26, 26, 24, 7, 3,512, ZSTD_btultra2}, /* level 21 */
	{ 27, 27, 25, 9, 3,999, ZSTD_btultra2}, /* level 22 */
	},
	{ /* for srcSize <= 256 KB */
	/* W, C, H, S, L, T, strat */
	{ 18, 12, 13, 1, 5, 1, ZSTD_fast }, /* base for negative levels */
	{ 18, 13, 14, 1, 6, 0, ZSTD_fast }, /* level 1 */
	{ 18, 14, 14, 1, 5, 0, ZSTD_dfast }, /* level 2 */
	{ 18, 16, 16, 1, 4, 0, ZSTD_dfast }, /* level 3 */
	{ 18, 16, 17, 2, 5, 2, ZSTD_greedy }, /* level 4.*/
	{ 18, 18, 18, 3, 5, 2, ZSTD_greedy }, /* level 5.*/
	{ 18, 18, 19, 3, 5, 4, ZSTD_lazy }, /* level 6.*/
	{ 18, 18, 19, 4, 4, 4, ZSTD_lazy }, /* level 7 */
	{ 18, 18, 19, 4, 4, 8, ZSTD_lazy2 }, /* level 8 */
	{ 18, 18, 19, 5, 4, 8, ZSTD_lazy2 }, /* level 9 */
	{ 18, 18, 19, 6, 4, 8, ZSTD_lazy2 }, /* level 10 */
	{ 18, 18, 19, 5, 4, 12, ZSTD_btlazy2 }, /* level 11.*/
	{ 18, 19, 19, 7, 4, 12, ZSTD_btlazy2 }, /* level 12.*/
	{ 18, 18, 19, 4, 4, 16, ZSTD_btopt }, /* level 13 */
	{ 18, 18, 19, 4, 3, 32, ZSTD_btopt }, /* level 14.*/
	{ 18, 18, 19, 6, 3,128, ZSTD_btopt }, /* level 15.*/
	{ 18, 19, 19, 6, 3,128, ZSTD_btultra }, /* level 16.*/
	{ 18, 19, 19, 8, 3,256, ZSTD_btultra }, /* level 17.*/
	{ 18, 19, 19, 6, 3,128, ZSTD_btultra2}, /* level 18.*/
	{ 18, 19, 19, 8, 3,256, ZSTD_btultra2}, /* level 19.*/
	{ 18, 19, 19, 10, 3,512, ZSTD_btultra2}, /* level 20.*/
	{ 18, 19, 19, 12, 3,512, ZSTD_btultra2}, /* level 21.*/
	{ 18, 19, 19, 13, 3,999, ZSTD_btultra2}, /* level 22.*/
	},
	{ /* for srcSize <= 128 KB */
	/* W, C, H, S, L, T, strat */
	{ 17, 12, 12, 1, 5, 1, ZSTD_fast }, /* base for negative levels */
	{ 17, 12, 13, 1, 6, 0, ZSTD_fast }, /* level 1 */
	{ 17, 13, 15, 1, 5, 0, ZSTD_fast }, /* level 2 */
	{ 17, 15, 16, 2, 5, 0, ZSTD_dfast }, /* level 3 */
	{ 17, 17, 17, 2, 4, 0, ZSTD_dfast }, /* level 4 */
	{ 17, 16, 17, 3, 4, 2, ZSTD_greedy }, /* level 5 */
	{ 17, 17, 17, 3, 4, 4, ZSTD_lazy }, /* level 6 */
	{ 17, 17, 17, 3, 4, 8, ZSTD_lazy2 }, /* level 7 */
	{ 17, 17, 17, 4, 4, 8, ZSTD_lazy2 }, /* level 8 */
	{ 17, 17, 17, 5, 4, 8, ZSTD_lazy2 }, /* level 9 */
	{ 17, 17, 17, 6, 4, 8, ZSTD_lazy2 }, /* level 10 */
	{ 17, 17, 17, 5, 4, 8, ZSTD_btlazy2 }, /* level 11 */
	{ 17, 18, 17, 7, 4, 12, ZSTD_btlazy2 }, /* level 12 */
	{ 17, 18, 17, 3, 4, 12, ZSTD_btopt }, /* level 13.*/
	{ 17, 18, 17, 4, 3, 32, ZSTD_btopt }, /* level 14.*/
	{ 17, 18, 17, 6, 3,256, ZSTD_btopt }, /* level 15.*/
	{ 17, 18, 17, 6, 3,128, ZSTD_btultra }, /* level 16.*/
	{ 17, 18, 17, 8, 3,256, ZSTD_btultra }, /* level 17.*/
	{ 17, 18, 17, 10, 3,512, ZSTD_btultra }, /* level 18.*/
	{ 17, 18, 17, 5, 3,256, ZSTD_btultra2}, /* level 19.*/
	{ 17, 18, 17, 7, 3,512, ZSTD_btultra2}, /* level 20.*/
	{ 17, 18, 17, 9, 3,512, ZSTD_btultra2}, /* level 21.*/
	{ 17, 18, 17, 11, 3,999, ZSTD_btultra2}, /* level 22.*/
	},
	{ /* for srcSize <= 16 KB */
	/* W, C, H, S, L, T, strat */
	{ 14, 12, 13, 1, 5, 1, ZSTD_fast }, /* base for negative levels */
	{ 14, 14, 15, 1, 5, 0, ZSTD_fast }, /* level 1 */
	{ 14, 14, 15, 1, 4, 0, ZSTD_fast }, /* level 2 */
	{ 14, 14, 15, 2, 4, 0, ZSTD_dfast }, /* level 3 */
	{ 14, 14, 14, 4, 4, 2, ZSTD_greedy }, /* level 4 */
	{ 14, 14, 14, 3, 4, 4, ZSTD_lazy }, /* level 5.*/
	{ 14, 14, 14, 4, 4, 8, ZSTD_lazy2 }, /* level 6 */
	{ 14, 14, 14, 6, 4, 8, ZSTD_lazy2 }, /* level 7 */
	{ 14, 14, 14, 8, 4, 8, ZSTD_lazy2 }, /* level 8.*/
	{ 14, 15, 14, 5, 4, 8, ZSTD_btlazy2 }, /* level 9.*/
	{ 14, 15, 14, 9, 4, 8, ZSTD_btlazy2 }, /* level 10.*/
	{ 14, 15, 14, 3, 4, 12, ZSTD_btopt }, /* level 11.*/
	{ 14, 15, 14, 4, 3, 24, ZSTD_btopt }, /* level 12.*/
	{ 14, 15, 14, 5, 3, 32, ZSTD_btultra }, /* level 13.*/
	{ 14, 15, 15, 6, 3, 64, ZSTD_btultra }, /* level 14.*/
	{ 14, 15, 15, 7, 3,256, ZSTD_btultra }, /* level 15.*/
	{ 14, 15, 15, 5, 3, 48, ZSTD_btultra2}, /* level 16.*/
	{ 14, 15, 15, 6, 3,128, ZSTD_btultra2}, /* level 17.*/
	{ 14, 15, 15, 7, 3,256, ZSTD_btultra2}, /* level 18.*/
	{ 14, 15, 15, 8, 3,256, ZSTD_btultra2}, /* level 19.*/
	{ 14, 15, 15, 8, 3,512, ZSTD_btultra2}, /* level 20.*/
	{ 14, 15, 15, 9, 3,512, ZSTD_btultra2}, /* level 21.*/
	{ 14, 15, 15, 10, 3,999, ZSTD_btultra2}, /* level 22.*/
	},
	};

	/*! ZSTD_getCParams_internal() :
	* @return ZSTD_compressionParameters structure for a selected compression level, srcSize and dictSize.
	* Note: srcSizeHint 0 means 0, use ZSTD_CONTENTSIZE_UNKNOWN for unknown.
	* Use dictSize == 0 for unknown or unused. */
	static ZSTD_compressionParameters ZSTD_getCParams_internal(int compressionLevel, unsigned long long srcSizeHint, size_t dictSize)
	{
	int const unknown = srcSizeHint == ZSTD_CONTENTSIZE_UNKNOWN;
	size_t const addedSize = unknown && dictSize > 0 ? 500 : 0;
	U64 const rSize = unknown && dictSize == 0 ? ZSTD_CONTENTSIZE_UNKNOWN : srcSizeHint+dictSize+addedSize;
	U32 const tableID = (rSize <= 256 KB) + (rSize <= 128 KB) + (rSize <= 16 KB);
	int row = compressionLevel;
	DEBUGLOG(5, "ZSTD_getCParams_internal (cLevel=%i)", compressionLevel);
	if (compressionLevel == 0) row = ZSTD_CLEVEL_DEFAULT; /* 0 == default */
	if (compressionLevel < 0) row = 0; /* entry 0 is baseline for fast mode */
	if (compressionLevel > ZSTD_MAX_CLEVEL) row = ZSTD_MAX_CLEVEL;
	{ ZSTD_compressionParameters cp = ZSTD_defaultCParameters[tableID][row];
	if (compressionLevel < 0) cp.targetLength = (unsigned)(-compressionLevel); /* acceleration factor */
	/* refine parameters based on srcSize & dictSize */
	return ZSTD_adjustCParams_internal(cp, srcSizeHint, dictSize);
	}
	}

	/*! ZSTD_getCParams() :
	* @return ZSTD_compressionParameters structure for a selected compression level, srcSize and dictSize.
	* Size values are optional, provide 0 if not known or unused */
	ZSTD_compressionParameters ZSTD_getCParams(int compressionLevel, unsigned long long srcSizeHint, size_t dictSize)
	{
	if (srcSizeHint == 0) srcSizeHint = ZSTD_CONTENTSIZE_UNKNOWN;
	return ZSTD_getCParams_internal(compressionLevel, srcSizeHint, dictSize);
	}

	/*! ZSTD_getParams() :
	* same idea as ZSTD_getCParams()
	* @return a `ZSTD_parameters` structure (instead of `ZSTD_compressionParameters`).
	* Fields of `ZSTD_frameParameters` are set to default values */
	static ZSTD_parameters ZSTD_getParams_internal(int compressionLevel, unsigned long long srcSizeHint, size_t dictSize) {
	ZSTD_parameters params;
	ZSTD_compressionParameters const cParams = ZSTD_getCParams_internal(compressionLevel, srcSizeHint, dictSize);
	DEBUGLOG(5, "ZSTD_getParams (cLevel=%i)", compressionLevel);
	memset(&params, 0, sizeof(params));
	params.cParams = cParams;
	params.fParams.contentSizeFlag = 1;
	return params;
	}

	/*! ZSTD_getParams() :
	* same idea as ZSTD_getCParams()
	* @return a `ZSTD_parameters` structure (instead of `ZSTD_compressionParameters`).
	* Fields of `ZSTD_frameParameters` are set to default values */
	ZSTD_parameters ZSTD_getParams(int compressionLevel, unsigned long long srcSizeHint, size_t dictSize) {
	if (srcSizeHint == 0) srcSizeHint = ZSTD_CONTENTSIZE_UNKNOWN;
	return ZSTD_getParams_internal(compressionLevel, srcSizeHint, dictSize);
	}
	/** ended inlining compress/zstd_compress.c **/
	/** start inlining compress/zstd_double_fast.c **/
	/*
	* Copyright (c) 2016-2020, Yann Collet, Facebook, Inc.
	* All rights reserved.
	*
	* This source code is licensed under both the BSD-style license (found in the
	* LICENSE file in the root directory of this source tree) and the GPLv2 (found
	* in the COPYING file in the root directory of this source tree).
	* You may select, at your option, one of the above-listed licenses.
	*/

	/** skipping file: zstd_compress_internal.h **/
	/** skipping file: zstd_double_fast.h **/


	void ZSTD_fillDoubleHashTable(ZSTD_matchState_t* ms,
	void const* end, ZSTD_dictTableLoadMethod_e dtlm)
	{
	const ZSTD_compressionParameters* const cParams = &ms->cParams;
	U32* const hashLarge = ms->hashTable;
	U32 const hBitsL = cParams->hashLog;
	U32 const mls = cParams->minMatch;
	U32* const hashSmall = ms->chainTable;
	U32 const hBitsS = cParams->chainLog;
	const BYTE* const base = ms->window.base;
	const BYTE* ip = base + ms->nextToUpdate;
	const BYTE* const iend = ((const BYTE*)end) - HASH_READ_SIZE;
	const U32 fastHashFillStep = 3;

	/* Always insert every fastHashFillStep position into the hash tables.
	* Insert the other positions into the large hash table if their entry
	* is empty.
	*/
	for (; ip + fastHashFillStep - 1 <= iend; ip += fastHashFillStep) {
	U32 const current = (U32)(ip - base);
	U32 i;
	for (i = 0; i < fastHashFillStep; ++i) {
	size_t const smHash = ZSTD_hashPtr(ip + i, hBitsS, mls);
	size_t const lgHash = ZSTD_hashPtr(ip + i, hBitsL, 8);
	if (i == 0)
	hashSmall[smHash] = current + i;
	if (i == 0 \|\| hashLarge[lgHash] == 0)
	hashLarge[lgHash] = current + i;
	/* Only load extra positions for ZSTD_dtlm_full */
	if (dtlm == ZSTD_dtlm_fast)
	break;
	} }
	}


	FORCE_INLINE_TEMPLATE
	size_t ZSTD_compressBlock_doubleFast_generic(
	ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
	void const* src, size_t srcSize,
	U32 const mls /* template */, ZSTD_dictMode_e const dictMode)
	{
	ZSTD_compressionParameters const* cParams = &ms->cParams;
	U32* const hashLong = ms->hashTable;
	const U32 hBitsL = cParams->hashLog;
	U32* const hashSmall = ms->chainTable;
	const U32 hBitsS = cParams->chainLog;
	const BYTE* const base = ms->window.base;
	const BYTE* const istart = (const BYTE*)src;
	const BYTE* ip = istart;
	const BYTE* anchor = istart;
	const U32 endIndex = (U32)((size_t)(istart - base) + srcSize);
	/* presumes that, if there is a dictionary, it must be using Attach mode */
	const U32 prefixLowestIndex = ZSTD_getLowestPrefixIndex(ms, endIndex, cParams->windowLog);
	const BYTE* const prefixLowest = base + prefixLowestIndex;
	const BYTE* const iend = istart + srcSize;
	const BYTE* const ilimit = iend - HASH_READ_SIZE;
	U32 offset_1=rep[0], offset_2=rep[1];
	U32 offsetSaved = 0;

	const ZSTD_matchState_t* const dms = ms->dictMatchState;
	const ZSTD_compressionParameters* const dictCParams =
	dictMode == ZSTD_dictMatchState ?
	&dms->cParams : NULL;
	const U32* const dictHashLong = dictMode == ZSTD_dictMatchState ?
	dms->hashTable : NULL;
	const U32* const dictHashSmall = dictMode == ZSTD_dictMatchState ?
	dms->chainTable : NULL;
	const U32 dictStartIndex = dictMode == ZSTD_dictMatchState ?
	dms->window.dictLimit : 0;
	const BYTE* const dictBase = dictMode == ZSTD_dictMatchState ?
	dms->window.base : NULL;
	const BYTE* const dictStart = dictMode == ZSTD_dictMatchState ?
	dictBase + dictStartIndex : NULL;
	const BYTE* const dictEnd = dictMode == ZSTD_dictMatchState ?
	dms->window.nextSrc : NULL;
	const U32 dictIndexDelta = dictMode == ZSTD_dictMatchState ?
	prefixLowestIndex - (U32)(dictEnd - dictBase) :
	0;
	const U32 dictHBitsL = dictMode == ZSTD_dictMatchState ?
	dictCParams->hashLog : hBitsL;
	const U32 dictHBitsS = dictMode == ZSTD_dictMatchState ?
	dictCParams->chainLog : hBitsS;
	const U32 dictAndPrefixLength = (U32)((ip - prefixLowest) + (dictEnd - dictStart));

	DEBUGLOG(5, "ZSTD_compressBlock_doubleFast_generic");

	assert(dictMode == ZSTD_noDict \|\| dictMode == ZSTD_dictMatchState);

	/* if a dictionary is attached, it must be within window range */
	if (dictMode == ZSTD_dictMatchState) {
	assert(ms->window.dictLimit + (1U << cParams->windowLog) >= endIndex);
	}

	/* init */
	ip += (dictAndPrefixLength == 0);
	if (dictMode == ZSTD_noDict) {
	U32 const current = (U32)(ip - base);
	U32 const windowLow = ZSTD_getLowestPrefixIndex(ms, current, cParams->windowLog);
	U32 const maxRep = current - windowLow;
	if (offset_2 > maxRep) offsetSaved = offset_2, offset_2 = 0;
	if (offset_1 > maxRep) offsetSaved = offset_1, offset_1 = 0;
	}
	if (dictMode == ZSTD_dictMatchState) {
	/* dictMatchState repCode checks don't currently handle repCode == 0
	* disabling. */
	assert(offset_1 <= dictAndPrefixLength);
	assert(offset_2 <= dictAndPrefixLength);
	}

	/* Main Search Loop */
	while (ip < ilimit) { /* < instead of <=, because repcode check at (ip+1) */
	size_t mLength;
	U32 offset;
	size_t const h2 = ZSTD_hashPtr(ip, hBitsL, 8);
	size_t const h = ZSTD_hashPtr(ip, hBitsS, mls);
	size_t const dictHL = ZSTD_hashPtr(ip, dictHBitsL, 8);
	size_t const dictHS = ZSTD_hashPtr(ip, dictHBitsS, mls);
	U32 const current = (U32)(ip-base);
	U32 const matchIndexL = hashLong[h2];
	U32 matchIndexS = hashSmall[h];
	const BYTE* matchLong = base + matchIndexL;
	const BYTE* match = base + matchIndexS;
	const U32 repIndex = current + 1 - offset_1;
	const BYTE* repMatch = (dictMode == ZSTD_dictMatchState
	&& repIndex < prefixLowestIndex) ?
	dictBase + (repIndex - dictIndexDelta) :
	base + repIndex;
	hashLong[h2] = hashSmall[h] = current; /* update hash tables */

	/* check dictMatchState repcode */
	if (dictMode == ZSTD_dictMatchState
	&& ((U32)((prefixLowestIndex-1) - repIndex) >= 3 /* intentional underflow */)
	&& (MEM_read32(repMatch) == MEM_read32(ip+1)) ) {
	const BYTE* repMatchEnd = repIndex < prefixLowestIndex ? dictEnd : iend;
	mLength = ZSTD_count_2segments(ip+1+4, repMatch+4, iend, repMatchEnd, prefixLowest) + 4;
	ip++;
	ZSTD_storeSeq(seqStore, (size_t)(ip-anchor), anchor, iend, 0, mLength-MINMATCH);
	goto _match_stored;
	}

	/* check noDict repcode */
	if ( dictMode == ZSTD_noDict
	&& ((offset_1 > 0) & (MEM_read32(ip+1-offset_1) == MEM_read32(ip+1)))) {
	mLength = ZSTD_count(ip+1+4, ip+1+4-offset_1, iend) + 4;
	ip++;
	ZSTD_storeSeq(seqStore, (size_t)(ip-anchor), anchor, iend, 0, mLength-MINMATCH);
	goto _match_stored;
	}

	if (matchIndexL > prefixLowestIndex) {
	/* check prefix long match */
	if (MEM_read64(matchLong) == MEM_read64(ip)) {
	mLength = ZSTD_count(ip+8, matchLong+8, iend) + 8;
	offset = (U32)(ip-matchLong);
	while (((ip>anchor) & (matchLong>prefixLowest)) && (ip[-1] == matchLong[-1])) { ip--; matchLong--; mLength++; } /* catch up */
	goto _match_found;
	}
	} else if (dictMode == ZSTD_dictMatchState) {
	/* check dictMatchState long match */
	U32 const dictMatchIndexL = dictHashLong[dictHL];
	const BYTE* dictMatchL = dictBase + dictMatchIndexL;
	assert(dictMatchL < dictEnd);

	if (dictMatchL > dictStart && MEM_read64(dictMatchL) == MEM_read64(ip)) {
	mLength = ZSTD_count_2segments(ip+8, dictMatchL+8, iend, dictEnd, prefixLowest) + 8;
	offset = (U32)(current - dictMatchIndexL - dictIndexDelta);
	while (((ip>anchor) & (dictMatchL>dictStart)) && (ip[-1] == dictMatchL[-1])) { ip--; dictMatchL--; mLength++; } /* catch up */
	goto _match_found;
	} }

	if (matchIndexS > prefixLowestIndex) {
	/* check prefix short match */
	if (MEM_read32(match) == MEM_read32(ip)) {
	goto _search_next_long;
	}
	} else if (dictMode == ZSTD_dictMatchState) {
	/* check dictMatchState short match */
	U32 const dictMatchIndexS = dictHashSmall[dictHS];
	match = dictBase + dictMatchIndexS;
	matchIndexS = dictMatchIndexS + dictIndexDelta;

	if (match > dictStart && MEM_read32(match) == MEM_read32(ip)) {
	goto _search_next_long;
	} }

	ip += ((ip-anchor) >> kSearchStrength) + 1;
	#if defined(__aarch64__)
	PREFETCH_L1(ip+256);
	#endif
	continue;

	_search_next_long:

	{ size_t const hl3 = ZSTD_hashPtr(ip+1, hBitsL, 8);
	size_t const dictHLNext = ZSTD_hashPtr(ip+1, dictHBitsL, 8);
	U32 const matchIndexL3 = hashLong[hl3];
	const BYTE* matchL3 = base + matchIndexL3;
	hashLong[hl3] = current + 1;

	/* check prefix long +1 match */
	if (matchIndexL3 > prefixLowestIndex) {
	if (MEM_read64(matchL3) == MEM_read64(ip+1)) {
	mLength = ZSTD_count(ip+9, matchL3+8, iend) + 8;
	ip++;
	offset = (U32)(ip-matchL3);
	while (((ip>anchor) & (matchL3>prefixLowest)) && (ip[-1] == matchL3[-1])) { ip--; matchL3--; mLength++; } /* catch up */
	goto _match_found;
	}
	} else if (dictMode == ZSTD_dictMatchState) {
	/* check dict long +1 match */
	U32 const dictMatchIndexL3 = dictHashLong[dictHLNext];
	const BYTE* dictMatchL3 = dictBase + dictMatchIndexL3;
	assert(dictMatchL3 < dictEnd);
	if (dictMatchL3 > dictStart && MEM_read64(dictMatchL3) == MEM_read64(ip+1)) {
	mLength = ZSTD_count_2segments(ip+1+8, dictMatchL3+8, iend, dictEnd, prefixLowest) + 8;
	ip++;
	offset = (U32)(current + 1 - dictMatchIndexL3 - dictIndexDelta);
	while (((ip>anchor) & (dictMatchL3>dictStart)) && (ip[-1] == dictMatchL3[-1])) { ip--; dictMatchL3--; mLength++; } /* catch up */
	goto _match_found;
	} } }

	/* if no long +1 match, explore the short match we found */
	if (dictMode == ZSTD_dictMatchState && matchIndexS < prefixLowestIndex) {
	mLength = ZSTD_count_2segments(ip+4, match+4, iend, dictEnd, prefixLowest) + 4;
	offset = (U32)(current - matchIndexS);
	while (((ip>anchor) & (match>dictStart)) && (ip[-1] == match[-1])) { ip--; match--; mLength++; } /* catch up */
	} else {
	mLength = ZSTD_count(ip+4, match+4, iend) + 4;
	offset = (U32)(ip - match);
	while (((ip>anchor) & (match>prefixLowest)) && (ip[-1] == match[-1])) { ip--; match--; mLength++; } /* catch up */
	}

	/* fall-through */

	_match_found:
	offset_2 = offset_1;
	offset_1 = offset;

	ZSTD_storeSeq(seqStore, (size_t)(ip-anchor), anchor, iend, offset + ZSTD_REP_MOVE, mLength-MINMATCH);

	_match_stored:
	/* match found */
	ip += mLength;
	anchor = ip;

	if (ip <= ilimit) {
	/* Complementary insertion */
	/* done after iLimit test, as candidates could be > iend-8 */
	{ U32 const indexToInsert = current+2;
	hashLong[ZSTD_hashPtr(base+indexToInsert, hBitsL, 8)] = indexToInsert;
	hashLong[ZSTD_hashPtr(ip-2, hBitsL, 8)] = (U32)(ip-2-base);
	hashSmall[ZSTD_hashPtr(base+indexToInsert, hBitsS, mls)] = indexToInsert;
	hashSmall[ZSTD_hashPtr(ip-1, hBitsS, mls)] = (U32)(ip-1-base);
	}

	/* check immediate repcode */
	if (dictMode == ZSTD_dictMatchState) {
	while (ip <= ilimit) {
	U32 const current2 = (U32)(ip-base);
	U32 const repIndex2 = current2 - offset_2;
	const BYTE* repMatch2 = dictMode == ZSTD_dictMatchState
	&& repIndex2 < prefixLowestIndex ?
	dictBase + repIndex2 - dictIndexDelta :
	base + repIndex2;
	if ( ((U32)((prefixLowestIndex-1) - (U32)repIndex2) >= 3 /* intentional overflow */)
	&& (MEM_read32(repMatch2) == MEM_read32(ip)) ) {
	const BYTE* const repEnd2 = repIndex2 < prefixLowestIndex ? dictEnd : iend;
	size_t const repLength2 = ZSTD_count_2segments(ip+4, repMatch2+4, iend, repEnd2, prefixLowest) + 4;
	U32 tmpOffset = offset_2; offset_2 = offset_1; offset_1 = tmpOffset; /* swap offset_2 <=> offset_1 */
	ZSTD_storeSeq(seqStore, 0, anchor, iend, 0, repLength2-MINMATCH);
	hashSmall[ZSTD_hashPtr(ip, hBitsS, mls)] = current2;
	hashLong[ZSTD_hashPtr(ip, hBitsL, 8)] = current2;
	ip += repLength2;
	anchor = ip;
	continue;
	}
	break;
	} }

	if (dictMode == ZSTD_noDict) {
	while ( (ip <= ilimit)
	&& ( (offset_2>0)
	& (MEM_read32(ip) == MEM_read32(ip - offset_2)) )) {
	/* store sequence */
	size_t const rLength = ZSTD_count(ip+4, ip+4-offset_2, iend) + 4;
	U32 const tmpOff = offset_2; offset_2 = offset_1; offset_1 = tmpOff; /* swap offset_2 <=> offset_1 */
	hashSmall[ZSTD_hashPtr(ip, hBitsS, mls)] = (U32)(ip-base);
	hashLong[ZSTD_hashPtr(ip, hBitsL, 8)] = (U32)(ip-base);
	ZSTD_storeSeq(seqStore, 0, anchor, iend, 0, rLength-MINMATCH);
	ip += rLength;
	anchor = ip;
	continue; /* faster when present ... (?) */
	} } }
	} /* while (ip < ilimit) */

	/* save reps for next block */
	rep[0] = offset_1 ? offset_1 : offsetSaved;
	rep[1] = offset_2 ? offset_2 : offsetSaved;

	/* Return the last literals size */
	return (size_t)(iend - anchor);
	}


	size_t ZSTD_compressBlock_doubleFast(
	ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
	void const* src, size_t srcSize)
	{
	const U32 mls = ms->cParams.minMatch;
	switch(mls)
	{
	default: /* includes case 3 */
	case 4 :
	return ZSTD_compressBlock_doubleFast_generic(ms, seqStore, rep, src, srcSize, 4, ZSTD_noDict);
	case 5 :
	return ZSTD_compressBlock_doubleFast_generic(ms, seqStore, rep, src, srcSize, 5, ZSTD_noDict);
	case 6 :
	return ZSTD_compressBlock_doubleFast_generic(ms, seqStore, rep, src, srcSize, 6, ZSTD_noDict);
	case 7 :
	return ZSTD_compressBlock_doubleFast_generic(ms, seqStore, rep, src, srcSize, 7, ZSTD_noDict);
	}
	}


	size_t ZSTD_compressBlock_doubleFast_dictMatchState(
	ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
	void const* src, size_t srcSize)
	{
	const U32 mls = ms->cParams.minMatch;
	switch(mls)
	{
	default: /* includes case 3 */
	case 4 :
	return ZSTD_compressBlock_doubleFast_generic(ms, seqStore, rep, src, srcSize, 4, ZSTD_dictMatchState);
	case 5 :
	return ZSTD_compressBlock_doubleFast_generic(ms, seqStore, rep, src, srcSize, 5, ZSTD_dictMatchState);
	case 6 :
	return ZSTD_compressBlock_doubleFast_generic(ms, seqStore, rep, src, srcSize, 6, ZSTD_dictMatchState);
	case 7 :
	return ZSTD_compressBlock_doubleFast_generic(ms, seqStore, rep, src, srcSize, 7, ZSTD_dictMatchState);
	}
	}


	static size_t ZSTD_compressBlock_doubleFast_extDict_generic(
	ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
	void const* src, size_t srcSize,
	U32 const mls /* template */)
	{
	ZSTD_compressionParameters const* cParams = &ms->cParams;
	U32* const hashLong = ms->hashTable;
	U32 const hBitsL = cParams->hashLog;
	U32* const hashSmall = ms->chainTable;
	U32 const hBitsS = cParams->chainLog;
	const BYTE* const istart = (const BYTE*)src;
	const BYTE* ip = istart;
	const BYTE* anchor = istart;
	const BYTE* const iend = istart + srcSize;
	const BYTE* const ilimit = iend - 8;
	const BYTE* const base = ms->window.base;
	const U32 endIndex = (U32)((size_t)(istart - base) + srcSize);
	const U32 lowLimit = ZSTD_getLowestMatchIndex(ms, endIndex, cParams->windowLog);
	const U32 dictStartIndex = lowLimit;
	const U32 dictLimit = ms->window.dictLimit;
	const U32 prefixStartIndex = (dictLimit > lowLimit) ? dictLimit : lowLimit;
	const BYTE* const prefixStart = base + prefixStartIndex;
	const BYTE* const dictBase = ms->window.dictBase;
	const BYTE* const dictStart = dictBase + dictStartIndex;
	const BYTE* const dictEnd = dictBase + prefixStartIndex;
	U32 offset_1=rep[0], offset_2=rep[1];

	DEBUGLOG(5, "ZSTD_compressBlock_doubleFast_extDict_generic (srcSize=%zu)", srcSize);

	/* if extDict is invalidated due to maxDistance, switch to "regular" variant */
	if (prefixStartIndex == dictStartIndex)
	return ZSTD_compressBlock_doubleFast_generic(ms, seqStore, rep, src, srcSize, mls, ZSTD_noDict);

	/* Search Loop */
	while (ip < ilimit) { /* < instead of <=, because (ip+1) */
	const size_t hSmall = ZSTD_hashPtr(ip, hBitsS, mls);
	const U32 matchIndex = hashSmall[hSmall];
	const BYTE* const matchBase = matchIndex < prefixStartIndex ? dictBase : base;
	const BYTE* match = matchBase + matchIndex;

	const size_t hLong = ZSTD_hashPtr(ip, hBitsL, 8);
	const U32 matchLongIndex = hashLong[hLong];
	const BYTE* const matchLongBase = matchLongIndex < prefixStartIndex ? dictBase : base;
	const BYTE* matchLong = matchLongBase + matchLongIndex;

	const U32 current = (U32)(ip-base);
	const U32 repIndex = current + 1 - offset_1; /* offset_1 expected <= current +1 */
	const BYTE* const repBase = repIndex < prefixStartIndex ? dictBase : base;
	const BYTE* const repMatch = repBase + repIndex;
	size_t mLength;
	hashSmall[hSmall] = hashLong[hLong] = current; /* update hash table */

	if ((((U32)((prefixStartIndex-1) - repIndex) >= 3) /* intentional underflow : ensure repIndex doesn't overlap dict + prefix */
	& (repIndex > dictStartIndex))
	&& (MEM_read32(repMatch) == MEM_read32(ip+1)) ) {
	const BYTE* repMatchEnd = repIndex < prefixStartIndex ? dictEnd : iend;
	mLength = ZSTD_count_2segments(ip+1+4, repMatch+4, iend, repMatchEnd, prefixStart) + 4;
	ip++;
	ZSTD_storeSeq(seqStore, (size_t)(ip-anchor), anchor, iend, 0, mLength-MINMATCH);
	} else {
	if ((matchLongIndex > dictStartIndex) && (MEM_read64(matchLong) == MEM_read64(ip))) {
	const BYTE* const matchEnd = matchLongIndex < prefixStartIndex ? dictEnd : iend;
	const BYTE* const lowMatchPtr = matchLongIndex < prefixStartIndex ? dictStart : prefixStart;
	U32 offset;
	mLength = ZSTD_count_2segments(ip+8, matchLong+8, iend, matchEnd, prefixStart) + 8;
	offset = current - matchLongIndex;
	while (((ip>anchor) & (matchLong>lowMatchPtr)) && (ip[-1] == matchLong[-1])) { ip--; matchLong--; mLength++; } /* catch up */
	offset_2 = offset_1;
	offset_1 = offset;
	ZSTD_storeSeq(seqStore, (size_t)(ip-anchor), anchor, iend, offset + ZSTD_REP_MOVE, mLength-MINMATCH);

	} else if ((matchIndex > dictStartIndex) && (MEM_read32(match) == MEM_read32(ip))) {
	size_t const h3 = ZSTD_hashPtr(ip+1, hBitsL, 8);
	U32 const matchIndex3 = hashLong[h3];
	const BYTE* const match3Base = matchIndex3 < prefixStartIndex ? dictBase : base;
	const BYTE* match3 = match3Base + matchIndex3;
	U32 offset;
	hashLong[h3] = current + 1;
	if ( (matchIndex3 > dictStartIndex) && (MEM_read64(match3) == MEM_read64(ip+1)) ) {
	const BYTE* const matchEnd = matchIndex3 < prefixStartIndex ? dictEnd : iend;
	const BYTE* const lowMatchPtr = matchIndex3 < prefixStartIndex ? dictStart : prefixStart;
	mLength = ZSTD_count_2segments(ip+9, match3+8, iend, matchEnd, prefixStart) + 8;
	ip++;
	offset = current+1 - matchIndex3;
	while (((ip>anchor) & (match3>lowMatchPtr)) && (ip[-1] == match3[-1])) { ip--; match3--; mLength++; } /* catch up */
	} else {
	const BYTE* const matchEnd = matchIndex < prefixStartIndex ? dictEnd : iend;
	const BYTE* const lowMatchPtr = matchIndex < prefixStartIndex ? dictStart : prefixStart;
	mLength = ZSTD_count_2segments(ip+4, match+4, iend, matchEnd, prefixStart) + 4;
	offset = current - matchIndex;
	while (((ip>anchor) & (match>lowMatchPtr)) && (ip[-1] == match[-1])) { ip--; match--; mLength++; } /* catch up */
	}
	offset_2 = offset_1;
	offset_1 = offset;
	ZSTD_storeSeq(seqStore, (size_t)(ip-anchor), anchor, iend, offset + ZSTD_REP_MOVE, mLength-MINMATCH);

	} else {
	ip += ((ip-anchor) >> kSearchStrength) + 1;
	continue;
	} }

	/* move to next sequence start */
	ip += mLength;
	anchor = ip;

	if (ip <= ilimit) {
	/* Complementary insertion */
	/* done after iLimit test, as candidates could be > iend-8 */
	{ U32 const indexToInsert = current+2;
	hashLong[ZSTD_hashPtr(base+indexToInsert, hBitsL, 8)] = indexToInsert;
	hashLong[ZSTD_hashPtr(ip-2, hBitsL, 8)] = (U32)(ip-2-base);
	hashSmall[ZSTD_hashPtr(base+indexToInsert, hBitsS, mls)] = indexToInsert;
	hashSmall[ZSTD_hashPtr(ip-1, hBitsS, mls)] = (U32)(ip-1-base);
	}

	/* check immediate repcode */
	while (ip <= ilimit) {
	U32 const current2 = (U32)(ip-base);
	U32 const repIndex2 = current2 - offset_2;
	const BYTE* repMatch2 = repIndex2 < prefixStartIndex ? dictBase + repIndex2 : base + repIndex2;
	if ( (((U32)((prefixStartIndex-1) - repIndex2) >= 3) /* intentional overflow : ensure repIndex2 doesn't overlap dict + prefix */
	& (repIndex2 > dictStartIndex))
	&& (MEM_read32(repMatch2) == MEM_read32(ip)) ) {
	const BYTE* const repEnd2 = repIndex2 < prefixStartIndex ? dictEnd : iend;
	size_t const repLength2 = ZSTD_count_2segments(ip+4, repMatch2+4, iend, repEnd2, prefixStart) + 4;
	U32 const tmpOffset = offset_2; offset_2 = offset_1; offset_1 = tmpOffset; /* swap offset_2 <=> offset_1 */
	ZSTD_storeSeq(seqStore, 0, anchor, iend, 0, repLength2-MINMATCH);
	hashSmall[ZSTD_hashPtr(ip, hBitsS, mls)] = current2;
	hashLong[ZSTD_hashPtr(ip, hBitsL, 8)] = current2;
	ip += repLength2;
	anchor = ip;
	continue;
	}
	break;
	} } }

	/* save reps for next block */
	rep[0] = offset_1;
	rep[1] = offset_2;

	/* Return the last literals size */
	return (size_t)(iend - anchor);
	}


	size_t ZSTD_compressBlock_doubleFast_extDict(
	ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
	void const* src, size_t srcSize)
	{
	U32 const mls = ms->cParams.minMatch;
	switch(mls)
	{
	default: /* includes case 3 */
	case 4 :
	return ZSTD_compressBlock_doubleFast_extDict_generic(ms, seqStore, rep, src, srcSize, 4);
	case 5 :
	return ZSTD_compressBlock_doubleFast_extDict_generic(ms, seqStore, rep, src, srcSize, 5);
	case 6 :
	return ZSTD_compressBlock_doubleFast_extDict_generic(ms, seqStore, rep, src, srcSize, 6);
	case 7 :
	return ZSTD_compressBlock_doubleFast_extDict_generic(ms, seqStore, rep, src, srcSize, 7);
	}
	}
	/** ended inlining compress/zstd_double_fast.c **/
	/** start inlining compress/zstd_fast.c **/
	/*
	* Copyright (c) 2016-2020, Yann Collet, Facebook, Inc.
	* All rights reserved.
	*
	* This source code is licensed under both the BSD-style license (found in the
	* LICENSE file in the root directory of this source tree) and the GPLv2 (found
	* in the COPYING file in the root directory of this source tree).
	* You may select, at your option, one of the above-listed licenses.
	*/

	/** skipping file: zstd_compress_internal.h **/
	/** skipping file: zstd_fast.h **/


	void ZSTD_fillHashTable(ZSTD_matchState_t* ms,
	const void* const end,
	ZSTD_dictTableLoadMethod_e dtlm)
	{
	const ZSTD_compressionParameters* const cParams = &ms->cParams;
	U32* const hashTable = ms->hashTable;
	U32 const hBits = cParams->hashLog;
	U32 const mls = cParams->minMatch;
	const BYTE* const base = ms->window.base;
	const BYTE* ip = base + ms->nextToUpdate;
	const BYTE* const iend = ((const BYTE*)end) - HASH_READ_SIZE;
	const U32 fastHashFillStep = 3;

	/* Always insert every fastHashFillStep position into the hash table.
	* Insert the other positions if their hash entry is empty.
	*/
	for ( ; ip + fastHashFillStep < iend + 2; ip += fastHashFillStep) {
	U32 const current = (U32)(ip - base);
	size_t const hash0 = ZSTD_hashPtr(ip, hBits, mls);
	hashTable[hash0] = current;
	if (dtlm == ZSTD_dtlm_fast) continue;
	/* Only load extra positions for ZSTD_dtlm_full */
	{ U32 p;
	for (p = 1; p < fastHashFillStep; ++p) {
	size_t const hash = ZSTD_hashPtr(ip + p, hBits, mls);
	if (hashTable[hash] == 0) { /* not yet filled */
	hashTable[hash] = current + p;
	} } } }
	}


	FORCE_INLINE_TEMPLATE size_t
	ZSTD_compressBlock_fast_generic(
	ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
	void const* src, size_t srcSize,
	U32 const mls)
	{
	const ZSTD_compressionParameters* const cParams = &ms->cParams;
	U32* const hashTable = ms->hashTable;
	U32 const hlog = cParams->hashLog;
	/* support stepSize of 0 */
	size_t const stepSize = cParams->targetLength + !(cParams->targetLength) + 1;
	const BYTE* const base = ms->window.base;
	const BYTE* const istart = (const BYTE*)src;
	/* We check ip0 (ip + 0) and ip1 (ip + 1) each loop */
	const BYTE* ip0 = istart;
	const BYTE* ip1;
	const BYTE* anchor = istart;
	const U32 endIndex = (U32)((size_t)(istart - base) + srcSize);
	const U32 prefixStartIndex = ZSTD_getLowestPrefixIndex(ms, endIndex, cParams->windowLog);
	const BYTE* const prefixStart = base + prefixStartIndex;
	const BYTE* const iend = istart + srcSize;
	const BYTE* const ilimit = iend - HASH_READ_SIZE;
	U32 offset_1=rep[0], offset_2=rep[1];
	U32 offsetSaved = 0;

	/* init */
	DEBUGLOG(5, "ZSTD_compressBlock_fast_generic");
	ip0 += (ip0 == prefixStart);
	ip1 = ip0 + 1;
	{ U32 const current = (U32)(ip0 - base);
	U32 const windowLow = ZSTD_getLowestPrefixIndex(ms, current, cParams->windowLog);
	U32 const maxRep = current - windowLow;
	if (offset_2 > maxRep) offsetSaved = offset_2, offset_2 = 0;
	if (offset_1 > maxRep) offsetSaved = offset_1, offset_1 = 0;
	}

	/* Main Search Loop */
	#ifdef __INTEL_COMPILER
	/* From intel 'The vector pragma indicates that the loop should be
	* vectorized if it is legal to do so'. Can be used together with
	* #pragma ivdep (but have opted to exclude that because intel
	* warns against using it).*/
	#pragma vector always
	#endif
	while (ip1 < ilimit) { /* < instead of <=, because check at ip0+2 */
	size_t mLength;
	BYTE const* ip2 = ip0 + 2;
	size_t const h0 = ZSTD_hashPtr(ip0, hlog, mls);
	U32 const val0 = MEM_read32(ip0);
	size_t const h1 = ZSTD_hashPtr(ip1, hlog, mls);
	U32 const val1 = MEM_read32(ip1);
	U32 const current0 = (U32)(ip0-base);
	U32 const current1 = (U32)(ip1-base);
	U32 const matchIndex0 = hashTable[h0];
	U32 const matchIndex1 = hashTable[h1];
	BYTE const* repMatch = ip2 - offset_1;
	const BYTE* match0 = base + matchIndex0;
	const BYTE* match1 = base + matchIndex1;
	U32 offcode;

	#if defined(__aarch64__)
	PREFETCH_L1(ip0+256);
	#endif

	hashTable[h0] = current0; /* update hash table */
	hashTable[h1] = current1; /* update hash table */

	assert(ip0 + 1 == ip1);

	if ((offset_1 > 0) & (MEM_read32(repMatch) == MEM_read32(ip2))) {
	mLength = (ip2[-1] == repMatch[-1]) ? 1 : 0;
	ip0 = ip2 - mLength;
	match0 = repMatch - mLength;
	mLength += 4;
	offcode = 0;
	goto _match;
	}
	if ((matchIndex0 > prefixStartIndex) && MEM_read32(match0) == val0) {
	/* found a regular match */
	goto _offset;
	}
	if ((matchIndex1 > prefixStartIndex) && MEM_read32(match1) == val1) {
	/* found a regular match after one literal */
	ip0 = ip1;
	match0 = match1;
	goto _offset;
	}
	{ size_t const step = ((size_t)(ip0-anchor) >> (kSearchStrength - 1)) + stepSize;
	assert(step >= 2);
	ip0 += step;
	ip1 += step;
	continue;
	}
	_offset: /* Requires: ip0, match0 */
	/* Compute the offset code */
	offset_2 = offset_1;
	offset_1 = (U32)(ip0-match0);
	offcode = offset_1 + ZSTD_REP_MOVE;
	mLength = 4;
	/* Count the backwards match length */
	while (((ip0>anchor) & (match0>prefixStart))
	&& (ip0[-1] == match0[-1])) { ip0--; match0--; mLength++; } /* catch up */

	_match: /* Requires: ip0, match0, offcode */
	/* Count the forward length */
	mLength += ZSTD_count(ip0+mLength, match0+mLength, iend);
	ZSTD_storeSeq(seqStore, (size_t)(ip0-anchor), anchor, iend, offcode, mLength-MINMATCH);
	/* match found */
	ip0 += mLength;
	anchor = ip0;

	if (ip0 <= ilimit) {
	/* Fill Table */
	assert(base+current0+2 > istart); /* check base overflow */
	hashTable[ZSTD_hashPtr(base+current0+2, hlog, mls)] = current0+2; /* here because current+2 could be > iend-8 */
	hashTable[ZSTD_hashPtr(ip0-2, hlog, mls)] = (U32)(ip0-2-base);

	if (offset_2 > 0) { /* offset_2==0 means offset_2 is invalidated */
	while ( (ip0 <= ilimit) && (MEM_read32(ip0) == MEM_read32(ip0 - offset_2)) ) {
	/* store sequence */
	size_t const rLength = ZSTD_count(ip0+4, ip0+4-offset_2, iend) + 4;
	{ U32 const tmpOff = offset_2; offset_2 = offset_1; offset_1 = tmpOff; } /* swap offset_2 <=> offset_1 */
	hashTable[ZSTD_hashPtr(ip0, hlog, mls)] = (U32)(ip0-base);
	ip0 += rLength;
	ZSTD_storeSeq(seqStore, 0 /litLen/, anchor, iend, 0 /offCode/, rLength-MINMATCH);
	anchor = ip0;
	continue; /* faster when present (confirmed on gcc-8) ... (?) */
	} } }
	ip1 = ip0 + 1;
	}

	/* save reps for next block */
	rep[0] = offset_1 ? offset_1 : offsetSaved;
	rep[1] = offset_2 ? offset_2 : offsetSaved;

	/* Return the last literals size */
	return (size_t)(iend - anchor);
	}


	size_t ZSTD_compressBlock_fast(
	ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
	void const* src, size_t srcSize)
	{
	U32 const mls = ms->cParams.minMatch;
	assert(ms->dictMatchState == NULL);
	switch(mls)
	{
	default: /* includes case 3 */
	case 4 :
	return ZSTD_compressBlock_fast_generic(ms, seqStore, rep, src, srcSize, 4);
	case 5 :
	return ZSTD_compressBlock_fast_generic(ms, seqStore, rep, src, srcSize, 5);
	case 6 :
	return ZSTD_compressBlock_fast_generic(ms, seqStore, rep, src, srcSize, 6);
	case 7 :
	return ZSTD_compressBlock_fast_generic(ms, seqStore, rep, src, srcSize, 7);
	}
	}

	FORCE_INLINE_TEMPLATE
	size_t ZSTD_compressBlock_fast_dictMatchState_generic(
	ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
	void const* src, size_t srcSize, U32 const mls)
	{
	const ZSTD_compressionParameters* const cParams = &ms->cParams;
	U32* const hashTable = ms->hashTable;
	U32 const hlog = cParams->hashLog;
	/* support stepSize of 0 */
	U32 const stepSize = cParams->targetLength + !(cParams->targetLength);
	const BYTE* const base = ms->window.base;
	const BYTE* const istart = (const BYTE*)src;
	const BYTE* ip = istart;
	const BYTE* anchor = istart;
	const U32 prefixStartIndex = ms->window.dictLimit;
	const BYTE* const prefixStart = base + prefixStartIndex;
	const BYTE* const iend = istart + srcSize;
	const BYTE* const ilimit = iend - HASH_READ_SIZE;
	U32 offset_1=rep[0], offset_2=rep[1];
	U32 offsetSaved = 0;

	const ZSTD_matchState_t* const dms = ms->dictMatchState;
	const ZSTD_compressionParameters* const dictCParams = &dms->cParams ;
	const U32* const dictHashTable = dms->hashTable;
	const U32 dictStartIndex = dms->window.dictLimit;
	const BYTE* const dictBase = dms->window.base;
	const BYTE* const dictStart = dictBase + dictStartIndex;
	const BYTE* const dictEnd = dms->window.nextSrc;
	const U32 dictIndexDelta = prefixStartIndex - (U32)(dictEnd - dictBase);
	const U32 dictAndPrefixLength = (U32)(ip - prefixStart + dictEnd - dictStart);
	const U32 dictHLog = dictCParams->hashLog;

	/* if a dictionary is still attached, it necessarily means that
	* it is within window size. So we just check it. */
	const U32 maxDistance = 1U << cParams->windowLog;
	const U32 endIndex = (U32)((size_t)(ip - base) + srcSize);
	assert(endIndex - prefixStartIndex <= maxDistance);
	(void)maxDistance; (void)endIndex; /* these variables are not used when assert() is disabled */

	/* ensure there will be no no underflow
	* when translating a dict index into a local index */
	assert(prefixStartIndex >= (U32)(dictEnd - dictBase));

	/* init */
	DEBUGLOG(5, "ZSTD_compressBlock_fast_dictMatchState_generic");
	ip += (dictAndPrefixLength == 0);
	/* dictMatchState repCode checks don't currently handle repCode == 0
	* disabling. */
	assert(offset_1 <= dictAndPrefixLength);
	assert(offset_2 <= dictAndPrefixLength);

	/* Main Search Loop */
	while (ip < ilimit) { /* < instead of <=, because repcode check at (ip+1) */
	size_t mLength;
	size_t const h = ZSTD_hashPtr(ip, hlog, mls);
	U32 const current = (U32)(ip-base);
	U32 const matchIndex = hashTable[h];
	const BYTE* match = base + matchIndex;
	const U32 repIndex = current + 1 - offset_1;
	const BYTE* repMatch = (repIndex < prefixStartIndex) ?
	dictBase + (repIndex - dictIndexDelta) :
	base + repIndex;
	hashTable[h] = current; /* update hash table */

	if ( ((U32)((prefixStartIndex-1) - repIndex) >= 3) /* intentional underflow : ensure repIndex isn't overlapping dict + prefix */
	&& (MEM_read32(repMatch) == MEM_read32(ip+1)) ) {
	const BYTE* const repMatchEnd = repIndex < prefixStartIndex ? dictEnd : iend;
	mLength = ZSTD_count_2segments(ip+1+4, repMatch+4, iend, repMatchEnd, prefixStart) + 4;
	ip++;
	ZSTD_storeSeq(seqStore, (size_t)(ip-anchor), anchor, iend, 0, mLength-MINMATCH);
	} else if ( (matchIndex <= prefixStartIndex) ) {
	size_t const dictHash = ZSTD_hashPtr(ip, dictHLog, mls);
	U32 const dictMatchIndex = dictHashTable[dictHash];
	const BYTE* dictMatch = dictBase + dictMatchIndex;
	if (dictMatchIndex <= dictStartIndex \|\|
	MEM_read32(dictMatch) != MEM_read32(ip)) {
	assert(stepSize >= 1);
	ip += ((ip-anchor) >> kSearchStrength) + stepSize;
	continue;
	} else {
	/* found a dict match */
	U32 const offset = (U32)(current-dictMatchIndex-dictIndexDelta);
	mLength = ZSTD_count_2segments(ip+4, dictMatch+4, iend, dictEnd, prefixStart) + 4;
	while (((ip>anchor) & (dictMatch>dictStart))
	&& (ip[-1] == dictMatch[-1])) {
	ip--; dictMatch--; mLength++;
	} /* catch up */
	offset_2 = offset_1;
	offset_1 = offset;
	ZSTD_storeSeq(seqStore, (size_t)(ip-anchor), anchor, iend, offset + ZSTD_REP_MOVE, mLength-MINMATCH);
	}
	} else if (MEM_read32(match) != MEM_read32(ip)) {
	/* it's not a match, and we're not going to check the dictionary */
	assert(stepSize >= 1);
	ip += ((ip-anchor) >> kSearchStrength) + stepSize;
	continue;
	} else {
	/* found a regular match */
	U32 const offset = (U32)(ip-match);
	mLength = ZSTD_count(ip+4, match+4, iend) + 4;
	while (((ip>anchor) & (match>prefixStart))
	&& (ip[-1] == match[-1])) { ip--; match--; mLength++; } /* catch up */
	offset_2 = offset_1;
	offset_1 = offset;
	ZSTD_storeSeq(seqStore, (size_t)(ip-anchor), anchor, iend, offset + ZSTD_REP_MOVE, mLength-MINMATCH);
	}

	/* match found */
	ip += mLength;
	anchor = ip;

	if (ip <= ilimit) {
	/* Fill Table */
	assert(base+current+2 > istart); /* check base overflow */
	hashTable[ZSTD_hashPtr(base+current+2, hlog, mls)] = current+2; /* here because current+2 could be > iend-8 */
	hashTable[ZSTD_hashPtr(ip-2, hlog, mls)] = (U32)(ip-2-base);

	/* check immediate repcode */
	while (ip <= ilimit) {
	U32 const current2 = (U32)(ip-base);
	U32 const repIndex2 = current2 - offset_2;
	const BYTE* repMatch2 = repIndex2 < prefixStartIndex ?
	dictBase - dictIndexDelta + repIndex2 :
	base + repIndex2;
	if ( ((U32)((prefixStartIndex-1) - (U32)repIndex2) >= 3 /* intentional overflow */)
	&& (MEM_read32(repMatch2) == MEM_read32(ip)) ) {
	const BYTE* const repEnd2 = repIndex2 < prefixStartIndex ? dictEnd : iend;
	size_t const repLength2 = ZSTD_count_2segments(ip+4, repMatch2+4, iend, repEnd2, prefixStart) + 4;
	U32 tmpOffset = offset_2; offset_2 = offset_1; offset_1 = tmpOffset; /* swap offset_2 <=> offset_1 */
	ZSTD_storeSeq(seqStore, 0, anchor, iend, 0, repLength2-MINMATCH);
	hashTable[ZSTD_hashPtr(ip, hlog, mls)] = current2;
	ip += repLength2;
	anchor = ip;
	continue;
	}
	break;
	}
	}
	}

	/* save reps for next block */
	rep[0] = offset_1 ? offset_1 : offsetSaved;
	rep[1] = offset_2 ? offset_2 : offsetSaved;

	/* Return the last literals size */
	return (size_t)(iend - anchor);
	}

	size_t ZSTD_compressBlock_fast_dictMatchState(
	ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
	void const* src, size_t srcSize)
	{
	U32 const mls = ms->cParams.minMatch;
	assert(ms->dictMatchState != NULL);
	switch(mls)
	{
	default: /* includes case 3 */
	case 4 :
	return ZSTD_compressBlock_fast_dictMatchState_generic(ms, seqStore, rep, src, srcSize, 4);
	case 5 :
	return ZSTD_compressBlock_fast_dictMatchState_generic(ms, seqStore, rep, src, srcSize, 5);
	case 6 :
	return ZSTD_compressBlock_fast_dictMatchState_generic(ms, seqStore, rep, src, srcSize, 6);
	case 7 :
	return ZSTD_compressBlock_fast_dictMatchState_generic(ms, seqStore, rep, src, srcSize, 7);
	}
	}


	static size_t ZSTD_compressBlock_fast_extDict_generic(
	ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
	void const* src, size_t srcSize, U32 const mls)
	{
	const ZSTD_compressionParameters* const cParams = &ms->cParams;
	U32* const hashTable = ms->hashTable;
	U32 const hlog = cParams->hashLog;
	/* support stepSize of 0 */
	U32 const stepSize = cParams->targetLength + !(cParams->targetLength);
	const BYTE* const base = ms->window.base;
	const BYTE* const dictBase = ms->window.dictBase;
	const BYTE* const istart = (const BYTE*)src;
	const BYTE* ip = istart;
	const BYTE* anchor = istart;
	const U32 endIndex = (U32)((size_t)(istart - base) + srcSize);
	const U32 lowLimit = ZSTD_getLowestMatchIndex(ms, endIndex, cParams->windowLog);
	const U32 dictStartIndex = lowLimit;
	const BYTE* const dictStart = dictBase + dictStartIndex;
	const U32 dictLimit = ms->window.dictLimit;
	const U32 prefixStartIndex = dictLimit < lowLimit ? lowLimit : dictLimit;
	const BYTE* const prefixStart = base + prefixStartIndex;
	const BYTE* const dictEnd = dictBase + prefixStartIndex;
	const BYTE* const iend = istart + srcSize;
	const BYTE* const ilimit = iend - 8;
	U32 offset_1=rep[0], offset_2=rep[1];

	DEBUGLOG(5, "ZSTD_compressBlock_fast_extDict_generic (offset_1=%u)", offset_1);

	/* switch to "regular" variant if extDict is invalidated due to maxDistance */
	if (prefixStartIndex == dictStartIndex)
	return ZSTD_compressBlock_fast_generic(ms, seqStore, rep, src, srcSize, mls);

	/* Search Loop */
	while (ip < ilimit) { /* < instead of <=, because (ip+1) */
	const size_t h = ZSTD_hashPtr(ip, hlog, mls);
	const U32 matchIndex = hashTable[h];
	const BYTE* const matchBase = matchIndex < prefixStartIndex ? dictBase : base;
	const BYTE* match = matchBase + matchIndex;
	const U32 current = (U32)(ip-base);
	const U32 repIndex = current + 1 - offset_1;
	const BYTE* const repBase = repIndex < prefixStartIndex ? dictBase : base;
	const BYTE* const repMatch = repBase + repIndex;
	hashTable[h] = current; /* update hash table */
	DEBUGLOG(7, "offset_1 = %u , current = %u", offset_1, current);
	assert(offset_1 <= current +1); /* check repIndex */

	if ( (((U32)((prefixStartIndex-1) - repIndex) >= 3) /* intentional underflow */ & (repIndex > dictStartIndex))
	&& (MEM_read32(repMatch) == MEM_read32(ip+1)) ) {
	const BYTE* const repMatchEnd = repIndex < prefixStartIndex ? dictEnd : iend;
	size_t const rLength = ZSTD_count_2segments(ip+1 +4, repMatch +4, iend, repMatchEnd, prefixStart) + 4;
	ip++;
	ZSTD_storeSeq(seqStore, (size_t)(ip-anchor), anchor, iend, 0, rLength-MINMATCH);
	ip += rLength;
	anchor = ip;
	} else {
	if ( (matchIndex < dictStartIndex) \|\|
	(MEM_read32(match) != MEM_read32(ip)) ) {
	assert(stepSize >= 1);
	ip += ((ip-anchor) >> kSearchStrength) + stepSize;
	continue;
	}
	{ const BYTE* const matchEnd = matchIndex < prefixStartIndex ? dictEnd : iend;
	const BYTE* const lowMatchPtr = matchIndex < prefixStartIndex ? dictStart : prefixStart;
	U32 const offset = current - matchIndex;
	size_t mLength = ZSTD_count_2segments(ip+4, match+4, iend, matchEnd, prefixStart) + 4;
	while (((ip>anchor) & (match>lowMatchPtr)) && (ip[-1] == match[-1])) { ip--; match--; mLength++; } /* catch up */
	offset_2 = offset_1; offset_1 = offset; /* update offset history */
	ZSTD_storeSeq(seqStore, (size_t)(ip-anchor), anchor, iend, offset + ZSTD_REP_MOVE, mLength-MINMATCH);
	ip += mLength;
	anchor = ip;
	} }

	if (ip <= ilimit) {
	/* Fill Table */
	hashTable[ZSTD_hashPtr(base+current+2, hlog, mls)] = current+2;
	hashTable[ZSTD_hashPtr(ip-2, hlog, mls)] = (U32)(ip-2-base);
	/* check immediate repcode */
	while (ip <= ilimit) {
	U32 const current2 = (U32)(ip-base);
	U32 const repIndex2 = current2 - offset_2;
	const BYTE* const repMatch2 = repIndex2 < prefixStartIndex ? dictBase + repIndex2 : base + repIndex2;
	if ( (((U32)((prefixStartIndex-1) - repIndex2) >= 3) & (repIndex2 > dictStartIndex)) /* intentional overflow */
	&& (MEM_read32(repMatch2) == MEM_read32(ip)) ) {
	const BYTE* const repEnd2 = repIndex2 < prefixStartIndex ? dictEnd : iend;
	size_t const repLength2 = ZSTD_count_2segments(ip+4, repMatch2+4, iend, repEnd2, prefixStart) + 4;
	{ U32 const tmpOffset = offset_2; offset_2 = offset_1; offset_1 = tmpOffset; } /* swap offset_2 <=> offset_1 */
	ZSTD_storeSeq(seqStore, 0 /litlen/, anchor, iend, 0 /offcode/, repLength2-MINMATCH);
	hashTable[ZSTD_hashPtr(ip, hlog, mls)] = current2;
	ip += repLength2;
	anchor = ip;
	continue;
	}
	break;
	} } }

	/* save reps for next block */
	rep[0] = offset_1;
	rep[1] = offset_2;

	/* Return the last literals size */
	return (size_t)(iend - anchor);
	}


	size_t ZSTD_compressBlock_fast_extDict(
	ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
	void const* src, size_t srcSize)
	{
	U32 const mls = ms->cParams.minMatch;
	switch(mls)
	{
	default: /* includes case 3 */
	case 4 :
	return ZSTD_compressBlock_fast_extDict_generic(ms, seqStore, rep, src, srcSize, 4);
	case 5 :
	return ZSTD_compressBlock_fast_extDict_generic(ms, seqStore, rep, src, srcSize, 5);
	case 6 :
	return ZSTD_compressBlock_fast_extDict_generic(ms, seqStore, rep, src, srcSize, 6);
	case 7 :
	return ZSTD_compressBlock_fast_extDict_generic(ms, seqStore, rep, src, srcSize, 7);
	}
	}
	/** ended inlining compress/zstd_fast.c **/
	/** start inlining compress/zstd_lazy.c **/
	/*
	* Copyright (c) 2016-2020, Yann Collet, Facebook, Inc.
	* All rights reserved.
	*
	* This source code is licensed under both the BSD-style license (found in the
	* LICENSE file in the root directory of this source tree) and the GPLv2 (found
	* in the COPYING file in the root directory of this source tree).
	* You may select, at your option, one of the above-listed licenses.
	*/

	/** skipping file: zstd_compress_internal.h **/
	/** skipping file: zstd_lazy.h **/


	/-************************************
	* Binary Tree search
	***************************************/

	static void
	ZSTD_updateDUBT(ZSTD_matchState_t* ms,
	const BYTE* ip, const BYTE* iend,
	U32 mls)
	{
	const ZSTD_compressionParameters* const cParams = &ms->cParams;
	U32* const hashTable = ms->hashTable;
	U32 const hashLog = cParams->hashLog;

	U32* const bt = ms->chainTable;
	U32 const btLog = cParams->chainLog - 1;
	U32 const btMask = (1 << btLog) - 1;

	const BYTE* const base = ms->window.base;
	U32 const target = (U32)(ip - base);
	U32 idx = ms->nextToUpdate;

	if (idx != target)
	DEBUGLOG(7, "ZSTD_updateDUBT, from %u to %u (dictLimit:%u)",
	idx, target, ms->window.dictLimit);
	assert(ip + 8 <= iend); /* condition for ZSTD_hashPtr */
	(void)iend;

	assert(idx >= ms->window.dictLimit); /* condition for valid base+idx */
	for ( ; idx < target ; idx++) {
	size_t const h = ZSTD_hashPtr(base + idx, hashLog, mls); /* assumption : ip + 8 <= iend */
	U32 const matchIndex = hashTable[h];

	U32* const nextCandidatePtr = bt + 2*(idx&btMask);
	U32* const sortMarkPtr = nextCandidatePtr + 1;

	DEBUGLOG(8, "ZSTD_updateDUBT: insert %u", idx);
	hashTable[h] = idx; /* Update Hash Table */
	nextCandidatePtr = matchIndex; / update BT like a chain */
	*sortMarkPtr = ZSTD_DUBT_UNSORTED_MARK;
	}
	ms->nextToUpdate = target;
	}


	/** ZSTD_insertDUBT1() :
	* sort one already inserted but unsorted position
	* assumption : current >= btlow == (current - btmask)
	* doesn't fail */
	static void
	ZSTD_insertDUBT1(ZSTD_matchState_t* ms,
	U32 current, const BYTE* inputEnd,
	U32 nbCompares, U32 btLow,
	const ZSTD_dictMode_e dictMode)
	{
	const ZSTD_compressionParameters* const cParams = &ms->cParams;
	U32* const bt = ms->chainTable;
	U32 const btLog = cParams->chainLog - 1;
	U32 const btMask = (1 << btLog) - 1;
	size_t commonLengthSmaller=0, commonLengthLarger=0;
	const BYTE* const base = ms->window.base;
	const BYTE* const dictBase = ms->window.dictBase;
	const U32 dictLimit = ms->window.dictLimit;
	const BYTE* const ip = (current>=dictLimit) ? base + current : dictBase + current;
	const BYTE* const iend = (current>=dictLimit) ? inputEnd : dictBase + dictLimit;
	const BYTE* const dictEnd = dictBase + dictLimit;
	const BYTE* const prefixStart = base + dictLimit;
	const BYTE* match;
	U32* smallerPtr = bt + 2*(current&btMask);
	U32* largerPtr = smallerPtr + 1;
	U32 matchIndex = smallerPtr; / this candidate is unsorted : next sorted candidate is reached through smallerPtr, while largerPtr contains previous unsorted candidate (which is already saved and can be overwritten) */
	U32 dummy32; /* to be nullified at the end */
	U32 const windowValid = ms->window.lowLimit;
	U32 const maxDistance = 1U << cParams->windowLog;
	U32 const windowLow = (current - windowValid > maxDistance) ? current - maxDistance : windowValid;


	DEBUGLOG(8, "ZSTD_insertDUBT1(%u) (dictLimit=%u, lowLimit=%u)",
	current, dictLimit, windowLow);
	assert(current >= btLow);
	assert(ip < iend); /* condition for ZSTD_count */

	while (nbCompares-- && (matchIndex > windowLow)) {
	U32* const nextPtr = bt + 2*(matchIndex & btMask);
	size_t matchLength = MIN(commonLengthSmaller, commonLengthLarger); /* guaranteed minimum nb of common bytes */
	assert(matchIndex < current);
	/* note : all candidates are now supposed sorted,
	* but it's still possible to have nextPtr[1] == ZSTD_DUBT_UNSORTED_MARK
	* when a real index has the same value as ZSTD_DUBT_UNSORTED_MARK */

	if ( (dictMode != ZSTD_extDict)
	\|\| (matchIndex+matchLength >= dictLimit) /* both in current segment*/
	\|\| (current < dictLimit) /* both in extDict */) {
	const BYTE* const mBase = ( (dictMode != ZSTD_extDict)
	\|\| (matchIndex+matchLength >= dictLimit)) ?
	base : dictBase;
	assert( (matchIndex+matchLength >= dictLimit) /* might be wrong if extDict is incorrectly set to 0 */
	\|\| (current < dictLimit) );
	match = mBase + matchIndex;
	matchLength += ZSTD_count(ip+matchLength, match+matchLength, iend);
	} else {
	match = dictBase + matchIndex;
	matchLength += ZSTD_count_2segments(ip+matchLength, match+matchLength, iend, dictEnd, prefixStart);
	if (matchIndex+matchLength >= dictLimit)
	match = base + matchIndex; /* preparation for next read of match[matchLength] */
	}

	DEBUGLOG(8, "ZSTD_insertDUBT1: comparing %u with %u : found %u common bytes ",
	current, matchIndex, (U32)matchLength);

	if (ip+matchLength == iend) { /* equal : no way to know if inf or sup */
	break; /* drop , to guarantee consistency ; miss a bit of compression, but other solutions can corrupt tree */
	}

	if (match[matchLength] < ip[matchLength]) { /* necessarily within buffer */
	/* match is smaller than current */
	smallerPtr = matchIndex; / update smaller idx */
	commonLengthSmaller = matchLength; /* all smaller will now have at least this guaranteed common length */
	if (matchIndex <= btLow) { smallerPtr=&dummy32; break; } /* beyond tree size, stop searching */
	DEBUGLOG(8, "ZSTD_insertDUBT1: %u (>btLow=%u) is smaller : next => %u",
	matchIndex, btLow, nextPtr[1]);
	smallerPtr = nextPtr+1; /* new "candidate" => larger than match, which was smaller than target */
	matchIndex = nextPtr[1]; /* new matchIndex, larger than previous and closer to current */
	} else {
	/* match is larger than current */
	*largerPtr = matchIndex;
	commonLengthLarger = matchLength;
	if (matchIndex <= btLow) { largerPtr=&dummy32; break; } /* beyond tree size, stop searching */
	DEBUGLOG(8, "ZSTD_insertDUBT1: %u (>btLow=%u) is larger => %u",
	matchIndex, btLow, nextPtr[0]);
	largerPtr = nextPtr;
	matchIndex = nextPtr[0];
	} }

	smallerPtr = largerPtr = 0;
	}


	static size_t
	ZSTD_DUBT_findBetterDictMatch (
	ZSTD_matchState_t* ms,
	const BYTE* const ip, const BYTE* const iend,
	size_t* offsetPtr,
	size_t bestLength,
	U32 nbCompares,
	U32 const mls,
	const ZSTD_dictMode_e dictMode)
	{
	const ZSTD_matchState_t * const dms = ms->dictMatchState;
	const ZSTD_compressionParameters* const dmsCParams = &dms->cParams;
	const U32 * const dictHashTable = dms->hashTable;
	U32 const hashLog = dmsCParams->hashLog;
	size_t const h = ZSTD_hashPtr(ip, hashLog, mls);
	U32 dictMatchIndex = dictHashTable[h];

	const BYTE* const base = ms->window.base;
	const BYTE* const prefixStart = base + ms->window.dictLimit;
	U32 const current = (U32)(ip-base);
	const BYTE* const dictBase = dms->window.base;
	const BYTE* const dictEnd = dms->window.nextSrc;
	U32 const dictHighLimit = (U32)(dms->window.nextSrc - dms->window.base);
	U32 const dictLowLimit = dms->window.lowLimit;
	U32 const dictIndexDelta = ms->window.lowLimit - dictHighLimit;

	U32* const dictBt = dms->chainTable;
	U32 const btLog = dmsCParams->chainLog - 1;
	U32 const btMask = (1 << btLog) - 1;
	U32 const btLow = (btMask >= dictHighLimit - dictLowLimit) ? dictLowLimit : dictHighLimit - btMask;

	size_t commonLengthSmaller=0, commonLengthLarger=0;

	(void)dictMode;
	assert(dictMode == ZSTD_dictMatchState);

	while (nbCompares-- && (dictMatchIndex > dictLowLimit)) {
	U32* const nextPtr = dictBt + 2*(dictMatchIndex & btMask);
	size_t matchLength = MIN(commonLengthSmaller, commonLengthLarger); /* guaranteed minimum nb of common bytes */
	const BYTE* match = dictBase + dictMatchIndex;
	matchLength += ZSTD_count_2segments(ip+matchLength, match+matchLength, iend, dictEnd, prefixStart);
	if (dictMatchIndex+matchLength >= dictHighLimit)
	match = base + dictMatchIndex + dictIndexDelta; /* to prepare for next usage of match[matchLength] */

	if (matchLength > bestLength) {
	U32 matchIndex = dictMatchIndex + dictIndexDelta;
	if ( (4*(int)(matchLength-bestLength)) > (int)(ZSTD_highbit32(current-matchIndex+1) - ZSTD_highbit32((U32)offsetPtr[0]+1)) ) {
	DEBUGLOG(9, "ZSTD_DUBT_findBetterDictMatch(%u) : found better match length %u -> %u and offsetCode %u -> %u (dictMatchIndex %u, matchIndex %u)",
	current, (U32)bestLength, (U32)matchLength, (U32)*offsetPtr, ZSTD_REP_MOVE + current - matchIndex, dictMatchIndex, matchIndex);
	bestLength = matchLength, *offsetPtr = ZSTD_REP_MOVE + current - matchIndex;
	}
	if (ip+matchLength == iend) { /* reached end of input : ip[matchLength] is not valid, no way to know if it's larger or smaller than match */
	break; /* drop, to guarantee consistency (miss a little bit of compression) */
	}
	}

	if (match[matchLength] < ip[matchLength]) {
	if (dictMatchIndex <= btLow) { break; } /* beyond tree size, stop the search */
	commonLengthSmaller = matchLength; /* all smaller will now have at least this guaranteed common length */
	dictMatchIndex = nextPtr[1]; /* new matchIndex larger than previous (closer to current) */
	} else {
	/* match is larger than current */
	if (dictMatchIndex <= btLow) { break; } /* beyond tree size, stop the search */
	commonLengthLarger = matchLength;
	dictMatchIndex = nextPtr[0];
	}
	}

	if (bestLength >= MINMATCH) {
	U32 const mIndex = current - ((U32)*offsetPtr - ZSTD_REP_MOVE); (void)mIndex;
	DEBUGLOG(8, "ZSTD_DUBT_findBetterDictMatch(%u) : found match of length %u and offsetCode %u (pos %u)",
	current, (U32)bestLength, (U32)*offsetPtr, mIndex);
	}
	return bestLength;

	}


	static size_t
	ZSTD_DUBT_findBestMatch(ZSTD_matchState_t* ms,
	const BYTE* const ip, const BYTE* const iend,
	size_t* offsetPtr,
	U32 const mls,
	const ZSTD_dictMode_e dictMode)
	{
	const ZSTD_compressionParameters* const cParams = &ms->cParams;
	U32* const hashTable = ms->hashTable;
	U32 const hashLog = cParams->hashLog;
	size_t const h = ZSTD_hashPtr(ip, hashLog, mls);
	U32 matchIndex = hashTable[h];

	const BYTE* const base = ms->window.base;
	U32 const current = (U32)(ip-base);
	U32 const windowLow = ZSTD_getLowestMatchIndex(ms, current, cParams->windowLog);

	U32* const bt = ms->chainTable;
	U32 const btLog = cParams->chainLog - 1;
	U32 const btMask = (1 << btLog) - 1;
	U32 const btLow = (btMask >= current) ? 0 : current - btMask;
	U32 const unsortLimit = MAX(btLow, windowLow);

	U32* nextCandidate = bt + 2*(matchIndex&btMask);
	U32* unsortedMark = bt + 2*(matchIndex&btMask) + 1;
	U32 nbCompares = 1U << cParams->searchLog;
	U32 nbCandidates = nbCompares;
	U32 previousCandidate = 0;

	DEBUGLOG(7, "ZSTD_DUBT_findBestMatch (%u) ", current);
	assert(ip <= iend-8); /* required for h calculation */

	/* reach end of unsorted candidates list */
	while ( (matchIndex > unsortLimit)
	&& (*unsortedMark == ZSTD_DUBT_UNSORTED_MARK)
	&& (nbCandidates > 1) ) {
	DEBUGLOG(8, "ZSTD_DUBT_findBestMatch: candidate %u is unsorted",
	matchIndex);
	unsortedMark = previousCandidate; / the unsortedMark becomes a reversed chain, to move up back to original position */
	previousCandidate = matchIndex;
	matchIndex = *nextCandidate;
	nextCandidate = bt + 2*(matchIndex&btMask);
	unsortedMark = bt + 2*(matchIndex&btMask) + 1;
	nbCandidates --;
	}

	/* nullify last candidate if it's still unsorted
	* simplification, detrimental to compression ratio, beneficial for speed */
	if ( (matchIndex > unsortLimit)
	&& (*unsortedMark==ZSTD_DUBT_UNSORTED_MARK) ) {
	DEBUGLOG(7, "ZSTD_DUBT_findBestMatch: nullify last unsorted candidate %u",
	matchIndex);
	nextCandidate = unsortedMark = 0;
	}

	/* batch sort stacked candidates */
	matchIndex = previousCandidate;
	while (matchIndex) { /* will end on matchIndex == 0 */
	U32* const nextCandidateIdxPtr = bt + 2*(matchIndex&btMask) + 1;
	U32 const nextCandidateIdx = *nextCandidateIdxPtr;
	ZSTD_insertDUBT1(ms, matchIndex, iend,
	nbCandidates, unsortLimit, dictMode);
	matchIndex = nextCandidateIdx;
	nbCandidates++;
	}

	/* find longest match */
	{ size_t commonLengthSmaller = 0, commonLengthLarger = 0;
	const BYTE* const dictBase = ms->window.dictBase;
	const U32 dictLimit = ms->window.dictLimit;
	const BYTE* const dictEnd = dictBase + dictLimit;
	const BYTE* const prefixStart = base + dictLimit;
	U32* smallerPtr = bt + 2*(current&btMask);
	U32* largerPtr = bt + 2*(current&btMask) + 1;
	U32 matchEndIdx = current + 8 + 1;
	U32 dummy32; /* to be nullified at the end */
	size_t bestLength = 0;

	matchIndex = hashTable[h];
	hashTable[h] = current; /* Update Hash Table */

	while (nbCompares-- && (matchIndex > windowLow)) {
	U32* const nextPtr = bt + 2*(matchIndex & btMask);
	size_t matchLength = MIN(commonLengthSmaller, commonLengthLarger); /* guaranteed minimum nb of common bytes */
	const BYTE* match;

	if ((dictMode != ZSTD_extDict) \|\| (matchIndex+matchLength >= dictLimit)) {
	match = base + matchIndex;
	matchLength += ZSTD_count(ip+matchLength, match+matchLength, iend);
	} else {
	match = dictBase + matchIndex;
	matchLength += ZSTD_count_2segments(ip+matchLength, match+matchLength, iend, dictEnd, prefixStart);
	if (matchIndex+matchLength >= dictLimit)
	match = base + matchIndex; /* to prepare for next usage of match[matchLength] */
	}

	if (matchLength > bestLength) {
	if (matchLength > matchEndIdx - matchIndex)
	matchEndIdx = matchIndex + (U32)matchLength;
	if ( (4*(int)(matchLength-bestLength)) > (int)(ZSTD_highbit32(current-matchIndex+1) - ZSTD_highbit32((U32)offsetPtr[0]+1)) )
	bestLength = matchLength, *offsetPtr = ZSTD_REP_MOVE + current - matchIndex;
	if (ip+matchLength == iend) { /* equal : no way to know if inf or sup */
	if (dictMode == ZSTD_dictMatchState) {
	nbCompares = 0; /* in addition to avoiding checking any
	* further in this loop, make sure we
	* skip checking in the dictionary. */
	}
	break; /* drop, to guarantee consistency (miss a little bit of compression) */
	}
	}

	if (match[matchLength] < ip[matchLength]) {
	/* match is smaller than current */
	smallerPtr = matchIndex; / update smaller idx */
	commonLengthSmaller = matchLength; /* all smaller will now have at least this guaranteed common length */
	if (matchIndex <= btLow) { smallerPtr=&dummy32; break; } /* beyond tree size, stop the search */
	smallerPtr = nextPtr+1; /* new "smaller" => larger of match */
	matchIndex = nextPtr[1]; /* new matchIndex larger than previous (closer to current) */
	} else {
	/* match is larger than current */
	*largerPtr = matchIndex;
	commonLengthLarger = matchLength;
	if (matchIndex <= btLow) { largerPtr=&dummy32; break; } /* beyond tree size, stop the search */
	largerPtr = nextPtr;
	matchIndex = nextPtr[0];
	} }

	smallerPtr = largerPtr = 0;

	if (dictMode == ZSTD_dictMatchState && nbCompares) {
	bestLength = ZSTD_DUBT_findBetterDictMatch(
	ms, ip, iend,
	offsetPtr, bestLength, nbCompares,
	mls, dictMode);
	}

	assert(matchEndIdx > current+8); /* ensure nextToUpdate is increased */
	ms->nextToUpdate = matchEndIdx - 8; /* skip repetitive patterns */
	if (bestLength >= MINMATCH) {
	U32 const mIndex = current - ((U32)*offsetPtr - ZSTD_REP_MOVE); (void)mIndex;
	DEBUGLOG(8, "ZSTD_DUBT_findBestMatch(%u) : found match of length %u and offsetCode %u (pos %u)",
	current, (U32)bestLength, (U32)*offsetPtr, mIndex);
	}
	return bestLength;
	}
	}


	/** ZSTD_BtFindBestMatch() : Tree updater, providing best match */
	FORCE_INLINE_TEMPLATE size_t
	ZSTD_BtFindBestMatch( ZSTD_matchState_t* ms,
	const BYTE* const ip, const BYTE* const iLimit,
	size_t* offsetPtr,
	const U32 mls /* template */,
	const ZSTD_dictMode_e dictMode)
	{
	DEBUGLOG(7, "ZSTD_BtFindBestMatch");
	if (ip < ms->window.base + ms->nextToUpdate) return 0; /* skipped area */
	ZSTD_updateDUBT(ms, ip, iLimit, mls);
	return ZSTD_DUBT_findBestMatch(ms, ip, iLimit, offsetPtr, mls, dictMode);
	}


	static size_t
	ZSTD_BtFindBestMatch_selectMLS ( ZSTD_matchState_t* ms,
	const BYTE* ip, const BYTE* const iLimit,
	size_t* offsetPtr)
	{
	switch(ms->cParams.minMatch)
	{
	default : /* includes case 3 */
	case 4 : return ZSTD_BtFindBestMatch(ms, ip, iLimit, offsetPtr, 4, ZSTD_noDict);
	case 5 : return ZSTD_BtFindBestMatch(ms, ip, iLimit, offsetPtr, 5, ZSTD_noDict);
	case 7 :
	case 6 : return ZSTD_BtFindBestMatch(ms, ip, iLimit, offsetPtr, 6, ZSTD_noDict);
	}
	}


	static size_t ZSTD_BtFindBestMatch_dictMatchState_selectMLS (
	ZSTD_matchState_t* ms,
	const BYTE* ip, const BYTE* const iLimit,
	size_t* offsetPtr)
	{
	switch(ms->cParams.minMatch)
	{
	default : /* includes case 3 */
	case 4 : return ZSTD_BtFindBestMatch(ms, ip, iLimit, offsetPtr, 4, ZSTD_dictMatchState);
	case 5 : return ZSTD_BtFindBestMatch(ms, ip, iLimit, offsetPtr, 5, ZSTD_dictMatchState);
	case 7 :
	case 6 : return ZSTD_BtFindBestMatch(ms, ip, iLimit, offsetPtr, 6, ZSTD_dictMatchState);
	}
	}


	static size_t ZSTD_BtFindBestMatch_extDict_selectMLS (
	ZSTD_matchState_t* ms,
	const BYTE* ip, const BYTE* const iLimit,
	size_t* offsetPtr)
	{
	switch(ms->cParams.minMatch)
	{
	default : /* includes case 3 */
	case 4 : return ZSTD_BtFindBestMatch(ms, ip, iLimit, offsetPtr, 4, ZSTD_extDict);
	case 5 : return ZSTD_BtFindBestMatch(ms, ip, iLimit, offsetPtr, 5, ZSTD_extDict);
	case 7 :
	case 6 : return ZSTD_BtFindBestMatch(ms, ip, iLimit, offsetPtr, 6, ZSTD_extDict);
	}
	}



	/* *********************************
	* Hash Chain
	***********************************/
	#define NEXT_IN_CHAIN(d, mask) chainTable[(d) & (mask)]

	/* Update chains up to ip (excluded)
	Assumption : always within prefix (i.e. not within extDict) */
	static U32 ZSTD_insertAndFindFirstIndex_internal(
	ZSTD_matchState_t* ms,
	const ZSTD_compressionParameters* const cParams,
	const BYTE* ip, U32 const mls)
	{
	U32* const hashTable = ms->hashTable;
	const U32 hashLog = cParams->hashLog;
	U32* const chainTable = ms->chainTable;
	const U32 chainMask = (1 << cParams->chainLog) - 1;
	const BYTE* const base = ms->window.base;
	const U32 target = (U32)(ip - base);
	U32 idx = ms->nextToUpdate;

	while(idx < target) { /* catch up */
	size_t const h = ZSTD_hashPtr(base+idx, hashLog, mls);
	NEXT_IN_CHAIN(idx, chainMask) = hashTable[h];
	hashTable[h] = idx;
	idx++;
	}

	ms->nextToUpdate = target;
	return hashTable[ZSTD_hashPtr(ip, hashLog, mls)];
	}

	U32 ZSTD_insertAndFindFirstIndex(ZSTD_matchState_t* ms, const BYTE* ip) {
	const ZSTD_compressionParameters* const cParams = &ms->cParams;
	return ZSTD_insertAndFindFirstIndex_internal(ms, cParams, ip, ms->cParams.minMatch);
	}


	/* inlining is important to hardwire a hot branch (template emulation) */
	FORCE_INLINE_TEMPLATE
	size_t ZSTD_HcFindBestMatch_generic (
	ZSTD_matchState_t* ms,
	const BYTE* const ip, const BYTE* const iLimit,
	size_t* offsetPtr,
	const U32 mls, const ZSTD_dictMode_e dictMode)
	{
	const ZSTD_compressionParameters* const cParams = &ms->cParams;
	U32* const chainTable = ms->chainTable;
	const U32 chainSize = (1 << cParams->chainLog);
	const U32 chainMask = chainSize-1;
	const BYTE* const base = ms->window.base;
	const BYTE* const dictBase = ms->window.dictBase;
	const U32 dictLimit = ms->window.dictLimit;
	const BYTE* const prefixStart = base + dictLimit;
	const BYTE* const dictEnd = dictBase + dictLimit;
	const U32 current = (U32)(ip-base);
	const U32 maxDistance = 1U << cParams->windowLog;
	const U32 lowestValid = ms->window.lowLimit;
	const U32 withinMaxDistance = (current - lowestValid > maxDistance) ? current - maxDistance : lowestValid;
	const U32 isDictionary = (ms->loadedDictEnd != 0);
	const U32 lowLimit = isDictionary ? lowestValid : withinMaxDistance;
	const U32 minChain = current > chainSize ? current - chainSize : 0;
	U32 nbAttempts = 1U << cParams->searchLog;
	size_t ml=4-1;

	/* HC4 match finder */
	U32 matchIndex = ZSTD_insertAndFindFirstIndex_internal(ms, cParams, ip, mls);

	for ( ; (matchIndex>lowLimit) & (nbAttempts>0) ; nbAttempts--) {
	size_t currentMl=0;
	if ((dictMode != ZSTD_extDict) \|\| matchIndex >= dictLimit) {
	const BYTE* const match = base + matchIndex;
	assert(matchIndex >= dictLimit); /* ensures this is true if dictMode != ZSTD_extDict */
	if (match[ml] == ip[ml]) /* potentially better */
	currentMl = ZSTD_count(ip, match, iLimit);
	} else {
	const BYTE* const match = dictBase + matchIndex;
	assert(match+4 <= dictEnd);
	if (MEM_read32(match) == MEM_read32(ip)) /* assumption : matchIndex <= dictLimit-4 (by table construction) */
	currentMl = ZSTD_count_2segments(ip+4, match+4, iLimit, dictEnd, prefixStart) + 4;
	}

	/* save best solution */
	if (currentMl > ml) {
	ml = currentMl;
	*offsetPtr = current - matchIndex + ZSTD_REP_MOVE;
	if (ip+currentMl == iLimit) break; /* best possible, avoids read overflow on next attempt */
	}

	if (matchIndex <= minChain) break;
	matchIndex = NEXT_IN_CHAIN(matchIndex, chainMask);
	}

	if (dictMode == ZSTD_dictMatchState) {
	const ZSTD_matchState_t* const dms = ms->dictMatchState;
	const U32* const dmsChainTable = dms->chainTable;
	const U32 dmsChainSize = (1 << dms->cParams.chainLog);
	const U32 dmsChainMask = dmsChainSize - 1;
	const U32 dmsLowestIndex = dms->window.dictLimit;
	const BYTE* const dmsBase = dms->window.base;
	const BYTE* const dmsEnd = dms->window.nextSrc;
	const U32 dmsSize = (U32)(dmsEnd - dmsBase);
	const U32 dmsIndexDelta = dictLimit - dmsSize;
	const U32 dmsMinChain = dmsSize > dmsChainSize ? dmsSize - dmsChainSize : 0;

	matchIndex = dms->hashTable[ZSTD_hashPtr(ip, dms->cParams.hashLog, mls)];

	for ( ; (matchIndex>dmsLowestIndex) & (nbAttempts>0) ; nbAttempts--) {
	size_t currentMl=0;
	const BYTE* const match = dmsBase + matchIndex;
	assert(match+4 <= dmsEnd);
	if (MEM_read32(match) == MEM_read32(ip)) /* assumption : matchIndex <= dictLimit-4 (by table construction) */
	currentMl = ZSTD_count_2segments(ip+4, match+4, iLimit, dmsEnd, prefixStart) + 4;

	/* save best solution */
	if (currentMl > ml) {
	ml = currentMl;
	*offsetPtr = current - (matchIndex + dmsIndexDelta) + ZSTD_REP_MOVE;
	if (ip+currentMl == iLimit) break; /* best possible, avoids read overflow on next attempt */
	}

	if (matchIndex <= dmsMinChain) break;
	matchIndex = dmsChainTable[matchIndex & dmsChainMask];
	}
	}

	return ml;
	}


	FORCE_INLINE_TEMPLATE size_t ZSTD_HcFindBestMatch_selectMLS (
	ZSTD_matchState_t* ms,
	const BYTE* ip, const BYTE* const iLimit,
	size_t* offsetPtr)
	{
	switch(ms->cParams.minMatch)
	{
	default : /* includes case 3 */
	case 4 : return ZSTD_HcFindBestMatch_generic(ms, ip, iLimit, offsetPtr, 4, ZSTD_noDict);
	case 5 : return ZSTD_HcFindBestMatch_generic(ms, ip, iLimit, offsetPtr, 5, ZSTD_noDict);
	case 7 :
	case 6 : return ZSTD_HcFindBestMatch_generic(ms, ip, iLimit, offsetPtr, 6, ZSTD_noDict);
	}
	}


	static size_t ZSTD_HcFindBestMatch_dictMatchState_selectMLS (
	ZSTD_matchState_t* ms,
	const BYTE* ip, const BYTE* const iLimit,
	size_t* offsetPtr)
	{
	switch(ms->cParams.minMatch)
	{
	default : /* includes case 3 */
	case 4 : return ZSTD_HcFindBestMatch_generic(ms, ip, iLimit, offsetPtr, 4, ZSTD_dictMatchState);
	case 5 : return ZSTD_HcFindBestMatch_generic(ms, ip, iLimit, offsetPtr, 5, ZSTD_dictMatchState);
	case 7 :
	case 6 : return ZSTD_HcFindBestMatch_generic(ms, ip, iLimit, offsetPtr, 6, ZSTD_dictMatchState);
	}
	}


	FORCE_INLINE_TEMPLATE size_t ZSTD_HcFindBestMatch_extDict_selectMLS (
	ZSTD_matchState_t* ms,
	const BYTE* ip, const BYTE* const iLimit,
	size_t* offsetPtr)
	{
	switch(ms->cParams.minMatch)
	{
	default : /* includes case 3 */
	case 4 : return ZSTD_HcFindBestMatch_generic(ms, ip, iLimit, offsetPtr, 4, ZSTD_extDict);
	case 5 : return ZSTD_HcFindBestMatch_generic(ms, ip, iLimit, offsetPtr, 5, ZSTD_extDict);
	case 7 :
	case 6 : return ZSTD_HcFindBestMatch_generic(ms, ip, iLimit, offsetPtr, 6, ZSTD_extDict);
	}
	}


	/* *******************************
	* Common parser - lazy strategy
	*********************************/
	typedef enum { search_hashChain, search_binaryTree } searchMethod_e;

	FORCE_INLINE_TEMPLATE size_t
	ZSTD_compressBlock_lazy_generic(
	ZSTD_matchState_t* ms, seqStore_t* seqStore,
	U32 rep[ZSTD_REP_NUM],
	const void* src, size_t srcSize,
	const searchMethod_e searchMethod, const U32 depth,
	ZSTD_dictMode_e const dictMode)
	{
	const BYTE* const istart = (const BYTE*)src;
	const BYTE* ip = istart;
	const BYTE* anchor = istart;
	const BYTE* const iend = istart + srcSize;
	const BYTE* const ilimit = iend - 8;
	const BYTE* const base = ms->window.base;
	const U32 prefixLowestIndex = ms->window.dictLimit;
	const BYTE* const prefixLowest = base + prefixLowestIndex;

	typedef size_t (*searchMax_f)(
	ZSTD_matchState_t* ms,
	const BYTE* ip, const BYTE* iLimit, size_t* offsetPtr);
	searchMax_f const searchMax = dictMode == ZSTD_dictMatchState ?
	(searchMethod==search_binaryTree ? ZSTD_BtFindBestMatch_dictMatchState_selectMLS
	: ZSTD_HcFindBestMatch_dictMatchState_selectMLS) :
	(searchMethod==search_binaryTree ? ZSTD_BtFindBestMatch_selectMLS
	: ZSTD_HcFindBestMatch_selectMLS);
	U32 offset_1 = rep[0], offset_2 = rep[1], savedOffset=0;

	const ZSTD_matchState_t* const dms = ms->dictMatchState;
	const U32 dictLowestIndex = dictMode == ZSTD_dictMatchState ?
	dms->window.dictLimit : 0;
	const BYTE* const dictBase = dictMode == ZSTD_dictMatchState ?
	dms->window.base : NULL;
	const BYTE* const dictLowest = dictMode == ZSTD_dictMatchState ?
	dictBase + dictLowestIndex : NULL;
	const BYTE* const dictEnd = dictMode == ZSTD_dictMatchState ?
	dms->window.nextSrc : NULL;
	const U32 dictIndexDelta = dictMode == ZSTD_dictMatchState ?
	prefixLowestIndex - (U32)(dictEnd - dictBase) :
	0;
	const U32 dictAndPrefixLength = (U32)((ip - prefixLowest) + (dictEnd - dictLowest));

	DEBUGLOG(5, "ZSTD_compressBlock_lazy_generic (dictMode=%u)", (U32)dictMode);

	/* init */
	ip += (dictAndPrefixLength == 0);
	if (dictMode == ZSTD_noDict) {
	U32 const current = (U32)(ip - base);
	U32 const windowLow = ZSTD_getLowestPrefixIndex(ms, current, ms->cParams.windowLog);
	U32 const maxRep = current - windowLow;
	if (offset_2 > maxRep) savedOffset = offset_2, offset_2 = 0;
	if (offset_1 > maxRep) savedOffset = offset_1, offset_1 = 0;
	}
	if (dictMode == ZSTD_dictMatchState) {
	/* dictMatchState repCode checks don't currently handle repCode == 0
	* disabling. */
	assert(offset_1 <= dictAndPrefixLength);
	assert(offset_2 <= dictAndPrefixLength);
	}

	/* Match Loop */
	#if defined(__GNUC__) && defined(__x86_64__)
	/* I've measured random a 5% speed loss on levels 5 & 6 (greedy) when the
	* code alignment is perturbed. To fix the instability align the loop on 32-bytes.
	*/
	__asm__(".p2align 5");
	#endif
	while (ip < ilimit) {
	size_t matchLength=0;
	size_t offset=0;
	const BYTE* start=ip+1;

	/* check repCode */
	if (dictMode == ZSTD_dictMatchState) {
	const U32 repIndex = (U32)(ip - base) + 1 - offset_1;
	const BYTE* repMatch = (dictMode == ZSTD_dictMatchState
	&& repIndex < prefixLowestIndex) ?
	dictBase + (repIndex - dictIndexDelta) :
	base + repIndex;
	if (((U32)((prefixLowestIndex-1) - repIndex) >= 3 /* intentional underflow */)
	&& (MEM_read32(repMatch) == MEM_read32(ip+1)) ) {
	const BYTE* repMatchEnd = repIndex < prefixLowestIndex ? dictEnd : iend;
	matchLength = ZSTD_count_2segments(ip+1+4, repMatch+4, iend, repMatchEnd, prefixLowest) + 4;
	if (depth==0) goto _storeSequence;
	}
	}
	if ( dictMode == ZSTD_noDict
	&& ((offset_1 > 0) & (MEM_read32(ip+1-offset_1) == MEM_read32(ip+1)))) {
	matchLength = ZSTD_count(ip+1+4, ip+1+4-offset_1, iend) + 4;
	if (depth==0) goto _storeSequence;
	}

	/* first search (depth 0) */
	{ size_t offsetFound = 999999999;
	size_t const ml2 = searchMax(ms, ip, iend, &offsetFound);
	if (ml2 > matchLength)
	matchLength = ml2, start = ip, offset=offsetFound;
	}

	if (matchLength < 4) {
	ip += ((ip-anchor) >> kSearchStrength) + 1; /* jump faster over incompressible sections */
	continue;
	}

	/* let's try to find a better solution */
	if (depth>=1)
	while (ip<ilimit) {
	ip ++;
	if ( (dictMode == ZSTD_noDict)
	&& (offset) && ((offset_1>0) & (MEM_read32(ip) == MEM_read32(ip - offset_1)))) {
	size_t const mlRep = ZSTD_count(ip+4, ip+4-offset_1, iend) + 4;
	int const gain2 = (int)(mlRep * 3);
	int const gain1 = (int)(matchLength*3 - ZSTD_highbit32((U32)offset+1) + 1);
	if ((mlRep >= 4) && (gain2 > gain1))
	matchLength = mlRep, offset = 0, start = ip;
	}
	if (dictMode == ZSTD_dictMatchState) {
	const U32 repIndex = (U32)(ip - base) - offset_1;
	const BYTE* repMatch = repIndex < prefixLowestIndex ?
	dictBase + (repIndex - dictIndexDelta) :
	base + repIndex;
	if (((U32)((prefixLowestIndex-1) - repIndex) >= 3 /* intentional underflow */)
	&& (MEM_read32(repMatch) == MEM_read32(ip)) ) {
	const BYTE* repMatchEnd = repIndex < prefixLowestIndex ? dictEnd : iend;
	size_t const mlRep = ZSTD_count_2segments(ip+4, repMatch+4, iend, repMatchEnd, prefixLowest) + 4;
	int const gain2 = (int)(mlRep * 3);
	int const gain1 = (int)(matchLength*3 - ZSTD_highbit32((U32)offset+1) + 1);
	if ((mlRep >= 4) && (gain2 > gain1))
	matchLength = mlRep, offset = 0, start = ip;
	}
	}
	{ size_t offset2=999999999;
	size_t const ml2 = searchMax(ms, ip, iend, &offset2);
	int const gain2 = (int)(ml24 - ZSTD_highbit32((U32)offset2+1)); / raw approx */
	int const gain1 = (int)(matchLength*4 - ZSTD_highbit32((U32)offset+1) + 4);
	if ((ml2 >= 4) && (gain2 > gain1)) {
	matchLength = ml2, offset = offset2, start = ip;
	continue; /* search a better one */
	} }

	/* let's find an even better one */
	if ((depth==2) && (ip<ilimit)) {
	ip ++;
	if ( (dictMode == ZSTD_noDict)
	&& (offset) && ((offset_1>0) & (MEM_read32(ip) == MEM_read32(ip - offset_1)))) {
	size_t const mlRep = ZSTD_count(ip+4, ip+4-offset_1, iend) + 4;
	int const gain2 = (int)(mlRep * 4);
	int const gain1 = (int)(matchLength*4 - ZSTD_highbit32((U32)offset+1) + 1);
	if ((mlRep >= 4) && (gain2 > gain1))
	matchLength = mlRep, offset = 0, start = ip;
	}
	if (dictMode == ZSTD_dictMatchState) {
	const U32 repIndex = (U32)(ip - base) - offset_1;
	const BYTE* repMatch = repIndex < prefixLowestIndex ?
	dictBase + (repIndex - dictIndexDelta) :
	base + repIndex;
	if (((U32)((prefixLowestIndex-1) - repIndex) >= 3 /* intentional underflow */)
	&& (MEM_read32(repMatch) == MEM_read32(ip)) ) {
	const BYTE* repMatchEnd = repIndex < prefixLowestIndex ? dictEnd : iend;
	size_t const mlRep = ZSTD_count_2segments(ip+4, repMatch+4, iend, repMatchEnd, prefixLowest) + 4;
	int const gain2 = (int)(mlRep * 4);
	int const gain1 = (int)(matchLength*4 - ZSTD_highbit32((U32)offset+1) + 1);
	if ((mlRep >= 4) && (gain2 > gain1))
	matchLength = mlRep, offset = 0, start = ip;
	}
	}
	{ size_t offset2=999999999;
	size_t const ml2 = searchMax(ms, ip, iend, &offset2);
	int const gain2 = (int)(ml24 - ZSTD_highbit32((U32)offset2+1)); / raw approx */
	int const gain1 = (int)(matchLength*4 - ZSTD_highbit32((U32)offset+1) + 7);
	if ((ml2 >= 4) && (gain2 > gain1)) {
	matchLength = ml2, offset = offset2, start = ip;
	continue;
	} } }
	break; /* nothing found : store previous solution */
	}

	/* NOTE:
	* start[-offset+ZSTD_REP_MOVE-1] is undefined behavior.
	* (-offset+ZSTD_REP_MOVE-1) is unsigned, and is added to start, which
	* overflows the pointer, which is undefined behavior.
	*/
	/* catch up */
	if (offset) {
	if (dictMode == ZSTD_noDict) {
	while ( ((start > anchor) & (start - (offset-ZSTD_REP_MOVE) > prefixLowest))
	&& (start[-1] == (start-(offset-ZSTD_REP_MOVE))[-1]) ) /* only search for offset within prefix */
	{ start--; matchLength++; }
	}
	if (dictMode == ZSTD_dictMatchState) {
	U32 const matchIndex = (U32)((start-base) - (offset - ZSTD_REP_MOVE));
	const BYTE* match = (matchIndex < prefixLowestIndex) ? dictBase + matchIndex - dictIndexDelta : base + matchIndex;
	const BYTE* const mStart = (matchIndex < prefixLowestIndex) ? dictLowest : prefixLowest;
	while ((start>anchor) && (match>mStart) && (start[-1] == match[-1])) { start--; match--; matchLength++; } /* catch up */
	}
	offset_2 = offset_1; offset_1 = (U32)(offset - ZSTD_REP_MOVE);
	}
	/* store sequence */
	_storeSequence:
	{ size_t const litLength = start - anchor;
	ZSTD_storeSeq(seqStore, litLength, anchor, iend, (U32)offset, matchLength-MINMATCH);
	anchor = ip = start + matchLength;
	}

	/* check immediate repcode */
	if (dictMode == ZSTD_dictMatchState) {
	while (ip <= ilimit) {
	U32 const current2 = (U32)(ip-base);
	U32 const repIndex = current2 - offset_2;
	const BYTE* repMatch = dictMode == ZSTD_dictMatchState
	&& repIndex < prefixLowestIndex ?
	dictBase - dictIndexDelta + repIndex :
	base + repIndex;
	if ( ((U32)((prefixLowestIndex-1) - (U32)repIndex) >= 3 /* intentional overflow */)
	&& (MEM_read32(repMatch) == MEM_read32(ip)) ) {
	const BYTE* const repEnd2 = repIndex < prefixLowestIndex ? dictEnd : iend;
	matchLength = ZSTD_count_2segments(ip+4, repMatch+4, iend, repEnd2, prefixLowest) + 4;
	offset = offset_2; offset_2 = offset_1; offset_1 = (U32)offset; /* swap offset_2 <=> offset_1 */
	ZSTD_storeSeq(seqStore, 0, anchor, iend, 0, matchLength-MINMATCH);
	ip += matchLength;
	anchor = ip;
	continue;
	}
	break;
	}
	}

	if (dictMode == ZSTD_noDict) {
	while ( ((ip <= ilimit) & (offset_2>0))
	&& (MEM_read32(ip) == MEM_read32(ip - offset_2)) ) {
	/* store sequence */
	matchLength = ZSTD_count(ip+4, ip+4-offset_2, iend) + 4;
	offset = offset_2; offset_2 = offset_1; offset_1 = (U32)offset; /* swap repcodes */
	ZSTD_storeSeq(seqStore, 0, anchor, iend, 0, matchLength-MINMATCH);
	ip += matchLength;
	anchor = ip;
	continue; /* faster when present ... (?) */
	} } }

	/* Save reps for next block */
	rep[0] = offset_1 ? offset_1 : savedOffset;
	rep[1] = offset_2 ? offset_2 : savedOffset;

	/* Return the last literals size */
	return (size_t)(iend - anchor);
	}


	size_t ZSTD_compressBlock_btlazy2(
	ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
	void const* src, size_t srcSize)
	{
	return ZSTD_compressBlock_lazy_generic(ms, seqStore, rep, src, srcSize, search_binaryTree, 2, ZSTD_noDict);
	}

	size_t ZSTD_compressBlock_lazy2(
	ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
	void const* src, size_t srcSize)
	{
	return ZSTD_compressBlock_lazy_generic(ms, seqStore, rep, src, srcSize, search_hashChain, 2, ZSTD_noDict);
	}

	size_t ZSTD_compressBlock_lazy(
	ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
	void const* src, size_t srcSize)
	{
	return ZSTD_compressBlock_lazy_generic(ms, seqStore, rep, src, srcSize, search_hashChain, 1, ZSTD_noDict);
	}

	size_t ZSTD_compressBlock_greedy(
	ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
	void const* src, size_t srcSize)
	{
	return ZSTD_compressBlock_lazy_generic(ms, seqStore, rep, src, srcSize, search_hashChain, 0, ZSTD_noDict);
	}

	size_t ZSTD_compressBlock_btlazy2_dictMatchState(
	ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
	void const* src, size_t srcSize)
	{
	return ZSTD_compressBlock_lazy_generic(ms, seqStore, rep, src, srcSize, search_binaryTree, 2, ZSTD_dictMatchState);
	}

	size_t ZSTD_compressBlock_lazy2_dictMatchState(
	ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
	void const* src, size_t srcSize)
	{
	return ZSTD_compressBlock_lazy_generic(ms, seqStore, rep, src, srcSize, search_hashChain, 2, ZSTD_dictMatchState);
	}

	size_t ZSTD_compressBlock_lazy_dictMatchState(
	ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
	void const* src, size_t srcSize)
	{
	return ZSTD_compressBlock_lazy_generic(ms, seqStore, rep, src, srcSize, search_hashChain, 1, ZSTD_dictMatchState);
	}

	size_t ZSTD_compressBlock_greedy_dictMatchState(
	ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
	void const* src, size_t srcSize)
	{
	return ZSTD_compressBlock_lazy_generic(ms, seqStore, rep, src, srcSize, search_hashChain, 0, ZSTD_dictMatchState);
	}


	FORCE_INLINE_TEMPLATE
	size_t ZSTD_compressBlock_lazy_extDict_generic(
	ZSTD_matchState_t* ms, seqStore_t* seqStore,
	U32 rep[ZSTD_REP_NUM],
	const void* src, size_t srcSize,
	const searchMethod_e searchMethod, const U32 depth)
	{
	const BYTE* const istart = (const BYTE*)src;
	const BYTE* ip = istart;
	const BYTE* anchor = istart;
	const BYTE* const iend = istart + srcSize;
	const BYTE* const ilimit = iend - 8;
	const BYTE* const base = ms->window.base;
	const U32 dictLimit = ms->window.dictLimit;
	const BYTE* const prefixStart = base + dictLimit;
	const BYTE* const dictBase = ms->window.dictBase;
	const BYTE* const dictEnd = dictBase + dictLimit;
	const BYTE* const dictStart = dictBase + ms->window.lowLimit;
	const U32 windowLog = ms->cParams.windowLog;

	typedef size_t (*searchMax_f)(
	ZSTD_matchState_t* ms,
	const BYTE* ip, const BYTE* iLimit, size_t* offsetPtr);
	searchMax_f searchMax = searchMethod==search_binaryTree ? ZSTD_BtFindBestMatch_extDict_selectMLS : ZSTD_HcFindBestMatch_extDict_selectMLS;

	U32 offset_1 = rep[0], offset_2 = rep[1];

	DEBUGLOG(5, "ZSTD_compressBlock_lazy_extDict_generic");

	/* init */
	ip += (ip == prefixStart);

	/* Match Loop */
	#if defined(__GNUC__) && defined(__x86_64__)
	/* I've measured random a 5% speed loss on levels 5 & 6 (greedy) when the
	* code alignment is perturbed. To fix the instability align the loop on 32-bytes.
	*/
	__asm__(".p2align 5");
	#endif
	while (ip < ilimit) {
	size_t matchLength=0;
	size_t offset=0;
	const BYTE* start=ip+1;
	U32 current = (U32)(ip-base);

	/* check repCode */
	{ const U32 windowLow = ZSTD_getLowestMatchIndex(ms, current+1, windowLog);
	const U32 repIndex = (U32)(current+1 - offset_1);
	const BYTE* const repBase = repIndex < dictLimit ? dictBase : base;
	const BYTE* const repMatch = repBase + repIndex;
	if (((U32)((dictLimit-1) - repIndex) >= 3) & (repIndex > windowLow)) /* intentional overflow */
	if (MEM_read32(ip+1) == MEM_read32(repMatch)) {
	/* repcode detected we should take it */
	const BYTE* const repEnd = repIndex < dictLimit ? dictEnd : iend;
	matchLength = ZSTD_count_2segments(ip+1+4, repMatch+4, iend, repEnd, prefixStart) + 4;
	if (depth==0) goto _storeSequence;
	} }

	/* first search (depth 0) */
	{ size_t offsetFound = 999999999;
	size_t const ml2 = searchMax(ms, ip, iend, &offsetFound);
	if (ml2 > matchLength)
	matchLength = ml2, start = ip, offset=offsetFound;
	}

	if (matchLength < 4) {
	ip += ((ip-anchor) >> kSearchStrength) + 1; /* jump faster over incompressible sections */
	continue;
	}

	/* let's try to find a better solution */
	if (depth>=1)
	while (ip<ilimit) {
	ip ++;
	current++;
	/* check repCode */
	if (offset) {
	const U32 windowLow = ZSTD_getLowestMatchIndex(ms, current, windowLog);
	const U32 repIndex = (U32)(current - offset_1);
	const BYTE* const repBase = repIndex < dictLimit ? dictBase : base;
	const BYTE* const repMatch = repBase + repIndex;
	if (((U32)((dictLimit-1) - repIndex) >= 3) & (repIndex > windowLow)) /* intentional overflow */
	if (MEM_read32(ip) == MEM_read32(repMatch)) {
	/* repcode detected */
	const BYTE* const repEnd = repIndex < dictLimit ? dictEnd : iend;
	size_t const repLength = ZSTD_count_2segments(ip+4, repMatch+4, iend, repEnd, prefixStart) + 4;
	int const gain2 = (int)(repLength * 3);
	int const gain1 = (int)(matchLength*3 - ZSTD_highbit32((U32)offset+1) + 1);
	if ((repLength >= 4) && (gain2 > gain1))
	matchLength = repLength, offset = 0, start = ip;
	} }

	/* search match, depth 1 */
	{ size_t offset2=999999999;
	size_t const ml2 = searchMax(ms, ip, iend, &offset2);
	int const gain2 = (int)(ml24 - ZSTD_highbit32((U32)offset2+1)); / raw approx */
	int const gain1 = (int)(matchLength*4 - ZSTD_highbit32((U32)offset+1) + 4);
	if ((ml2 >= 4) && (gain2 > gain1)) {
	matchLength = ml2, offset = offset2, start = ip;
	continue; /* search a better one */
	} }

	/* let's find an even better one */
	if ((depth==2) && (ip<ilimit)) {
	ip ++;
	current++;
	/* check repCode */
	if (offset) {
	const U32 windowLow = ZSTD_getLowestMatchIndex(ms, current, windowLog);
	const U32 repIndex = (U32)(current - offset_1);
	const BYTE* const repBase = repIndex < dictLimit ? dictBase : base;
	const BYTE* const repMatch = repBase + repIndex;
	if (((U32)((dictLimit-1) - repIndex) >= 3) & (repIndex > windowLow)) /* intentional overflow */
	if (MEM_read32(ip) == MEM_read32(repMatch)) {
	/* repcode detected */
	const BYTE* const repEnd = repIndex < dictLimit ? dictEnd : iend;
	size_t const repLength = ZSTD_count_2segments(ip+4, repMatch+4, iend, repEnd, prefixStart) + 4;
	int const gain2 = (int)(repLength * 4);
	int const gain1 = (int)(matchLength*4 - ZSTD_highbit32((U32)offset+1) + 1);
	if ((repLength >= 4) && (gain2 > gain1))
	matchLength = repLength, offset = 0, start = ip;
	} }

	/* search match, depth 2 */
	{ size_t offset2=999999999;
	size_t const ml2 = searchMax(ms, ip, iend, &offset2);
	int const gain2 = (int)(ml24 - ZSTD_highbit32((U32)offset2+1)); / raw approx */
	int const gain1 = (int)(matchLength*4 - ZSTD_highbit32((U32)offset+1) + 7);
	if ((ml2 >= 4) && (gain2 > gain1)) {
	matchLength = ml2, offset = offset2, start = ip;
	continue;
	} } }
	break; /* nothing found : store previous solution */
	}

	/* catch up */
	if (offset) {
	U32 const matchIndex = (U32)((start-base) - (offset - ZSTD_REP_MOVE));
	const BYTE* match = (matchIndex < dictLimit) ? dictBase + matchIndex : base + matchIndex;
	const BYTE* const mStart = (matchIndex < dictLimit) ? dictStart : prefixStart;
	while ((start>anchor) && (match>mStart) && (start[-1] == match[-1])) { start--; match--; matchLength++; } /* catch up */
	offset_2 = offset_1; offset_1 = (U32)(offset - ZSTD_REP_MOVE);
	}

	/* store sequence */
	_storeSequence:
	{ size_t const litLength = start - anchor;
	ZSTD_storeSeq(seqStore, litLength, anchor, iend, (U32)offset, matchLength-MINMATCH);
	anchor = ip = start + matchLength;
	}

	/* check immediate repcode */
	while (ip <= ilimit) {
	const U32 repCurrent = (U32)(ip-base);
	const U32 windowLow = ZSTD_getLowestMatchIndex(ms, repCurrent, windowLog);
	const U32 repIndex = repCurrent - offset_2;
	const BYTE* const repBase = repIndex < dictLimit ? dictBase : base;
	const BYTE* const repMatch = repBase + repIndex;
	if (((U32)((dictLimit-1) - repIndex) >= 3) & (repIndex > windowLow)) /* intentional overflow */
	if (MEM_read32(ip) == MEM_read32(repMatch)) {
	/* repcode detected we should take it */
	const BYTE* const repEnd = repIndex < dictLimit ? dictEnd : iend;
	matchLength = ZSTD_count_2segments(ip+4, repMatch+4, iend, repEnd, prefixStart) + 4;
	offset = offset_2; offset_2 = offset_1; offset_1 = (U32)offset; /* swap offset history */
	ZSTD_storeSeq(seqStore, 0, anchor, iend, 0, matchLength-MINMATCH);
	ip += matchLength;
	anchor = ip;
	continue; /* faster when present ... (?) */
	}
	break;
	} }

	/* Save reps for next block */
	rep[0] = offset_1;
	rep[1] = offset_2;

	/* Return the last literals size */
	return (size_t)(iend - anchor);
	}


	size_t ZSTD_compressBlock_greedy_extDict(
	ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
	void const* src, size_t srcSize)
	{
	return ZSTD_compressBlock_lazy_extDict_generic(ms, seqStore, rep, src, srcSize, search_hashChain, 0);
	}

	size_t ZSTD_compressBlock_lazy_extDict(
	ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
	void const* src, size_t srcSize)

	{
	return ZSTD_compressBlock_lazy_extDict_generic(ms, seqStore, rep, src, srcSize, search_hashChain, 1);
	}

	size_t ZSTD_compressBlock_lazy2_extDict(
	ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
	void const* src, size_t srcSize)

	{
	return ZSTD_compressBlock_lazy_extDict_generic(ms, seqStore, rep, src, srcSize, search_hashChain, 2);
	}

	size_t ZSTD_compressBlock_btlazy2_extDict(
	ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
	void const* src, size_t srcSize)

	{
	return ZSTD_compressBlock_lazy_extDict_generic(ms, seqStore, rep, src, srcSize, search_binaryTree, 2);
	}
	/** ended inlining compress/zstd_lazy.c **/
	/** start inlining compress/zstd_ldm.c **/
	/*
	* Copyright (c) 2016-2020, Yann Collet, Facebook, Inc.
	* All rights reserved.
	*
	* This source code is licensed under both the BSD-style license (found in the
	* LICENSE file in the root directory of this source tree) and the GPLv2 (found
	* in the COPYING file in the root directory of this source tree).
	* You may select, at your option, one of the above-listed licenses.
	*/

	/** skipping file: zstd_ldm.h **/

	/** skipping file: ../common/debug.h **/
	/** skipping file: zstd_fast.h **/
	/** skipping file: zstd_double_fast.h **/

	#define LDM_BUCKET_SIZE_LOG 3
	#define LDM_MIN_MATCH_LENGTH 64
	#define LDM_HASH_RLOG 7
	#define LDM_HASH_CHAR_OFFSET 10

	void ZSTD_ldm_adjustParameters(ldmParams_t* params,
	ZSTD_compressionParameters const* cParams)
	{
	params->windowLog = cParams->windowLog;
	ZSTD_STATIC_ASSERT(LDM_BUCKET_SIZE_LOG <= ZSTD_LDM_BUCKETSIZELOG_MAX);
	DEBUGLOG(4, "ZSTD_ldm_adjustParameters");
	if (!params->bucketSizeLog) params->bucketSizeLog = LDM_BUCKET_SIZE_LOG;
	if (!params->minMatchLength) params->minMatchLength = LDM_MIN_MATCH_LENGTH;
	if (cParams->strategy >= ZSTD_btopt) {
	/* Get out of the way of the optimal parser */
	U32 const minMatch = MAX(cParams->targetLength, params->minMatchLength);
	assert(minMatch >= ZSTD_LDM_MINMATCH_MIN);
	assert(minMatch <= ZSTD_LDM_MINMATCH_MAX);
	params->minMatchLength = minMatch;
	}
	if (params->hashLog == 0) {
	params->hashLog = MAX(ZSTD_HASHLOG_MIN, params->windowLog - LDM_HASH_RLOG);
	assert(params->hashLog <= ZSTD_HASHLOG_MAX);
	}
	if (params->hashRateLog == 0) {
	params->hashRateLog = params->windowLog < params->hashLog
	? 0
	: params->windowLog - params->hashLog;
	}
	params->bucketSizeLog = MIN(params->bucketSizeLog, params->hashLog);
	}

	size_t ZSTD_ldm_getTableSize(ldmParams_t params)
	{
	size_t const ldmHSize = ((size_t)1) << params.hashLog;
	size_t const ldmBucketSizeLog = MIN(params.bucketSizeLog, params.hashLog);
	size_t const ldmBucketSize = ((size_t)1) << (params.hashLog - ldmBucketSizeLog);
	size_t const totalSize = ZSTD_cwksp_alloc_size(ldmBucketSize)
	+ ZSTD_cwksp_alloc_size(ldmHSize * sizeof(ldmEntry_t));
	return params.enableLdm ? totalSize : 0;
	}

	size_t ZSTD_ldm_getMaxNbSeq(ldmParams_t params, size_t maxChunkSize)
	{
	return params.enableLdm ? (maxChunkSize / params.minMatchLength) : 0;
	}

	/** ZSTD_ldm_getSmallHash() :
	* numBits should be <= 32
	* If numBits==0, returns 0.
	* @return : the most significant numBits of value. */
	static U32 ZSTD_ldm_getSmallHash(U64 value, U32 numBits)
	{
	assert(numBits <= 32);
	return numBits == 0 ? 0 : (U32)(value >> (64 - numBits));
	}

	/** ZSTD_ldm_getChecksum() :
	* numBitsToDiscard should be <= 32
	* @return : the next most significant 32 bits after numBitsToDiscard */
	static U32 ZSTD_ldm_getChecksum(U64 hash, U32 numBitsToDiscard)
	{
	assert(numBitsToDiscard <= 32);
	return (hash >> (64 - 32 - numBitsToDiscard)) & 0xFFFFFFFF;
	}

	/** ZSTD_ldm_getTag() ;
	* Given the hash, returns the most significant numTagBits bits
	* after (32 + hbits) bits.
	*
	* If there are not enough bits remaining, return the last
	* numTagBits bits. */
	static U32 ZSTD_ldm_getTag(U64 hash, U32 hbits, U32 numTagBits)
	{
	assert(numTagBits < 32 && hbits <= 32);
	if (32 - hbits < numTagBits) {
	return hash & (((U32)1 << numTagBits) - 1);
	} else {
	return (hash >> (32 - hbits - numTagBits)) & (((U32)1 << numTagBits) - 1);
	}
	}

	/** ZSTD_ldm_getBucket() :
	* Returns a pointer to the start of the bucket associated with hash. */
	static ldmEntry_t* ZSTD_ldm_getBucket(
	ldmState_t* ldmState, size_t hash, ldmParams_t const ldmParams)
	{
	return ldmState->hashTable + (hash << ldmParams.bucketSizeLog);
	}

	/** ZSTD_ldm_insertEntry() :
	* Insert the entry with corresponding hash into the hash table */
	static void ZSTD_ldm_insertEntry(ldmState_t* ldmState,
	size_t const hash, const ldmEntry_t entry,
	ldmParams_t const ldmParams)
	{
	BYTE* const bucketOffsets = ldmState->bucketOffsets;
	*(ZSTD_ldm_getBucket(ldmState, hash, ldmParams) + bucketOffsets[hash]) = entry;
	bucketOffsets[hash]++;
	bucketOffsets[hash] &= ((U32)1 << ldmParams.bucketSizeLog) - 1;
	}

	/** ZSTD_ldm_makeEntryAndInsertByTag() :
	*
	* Gets the small hash, checksum, and tag from the rollingHash.
	*
	* If the tag matches (1 << ldmParams.hashRateLog)-1, then
	* creates an ldmEntry from the offset, and inserts it into the hash table.
	*
	* hBits is the length of the small hash, which is the most significant hBits
	* of rollingHash. The checksum is the next 32 most significant bits, followed
	* by ldmParams.hashRateLog bits that make up the tag. */
	static void ZSTD_ldm_makeEntryAndInsertByTag(ldmState_t* ldmState,
	U64 const rollingHash,
	U32 const hBits,
	U32 const offset,
	ldmParams_t const ldmParams)
	{
	U32 const tag = ZSTD_ldm_getTag(rollingHash, hBits, ldmParams.hashRateLog);
	U32 const tagMask = ((U32)1 << ldmParams.hashRateLog) - 1;
	if (tag == tagMask) {
	U32 const hash = ZSTD_ldm_getSmallHash(rollingHash, hBits);
	U32 const checksum = ZSTD_ldm_getChecksum(rollingHash, hBits);
	ldmEntry_t entry;
	entry.offset = offset;
	entry.checksum = checksum;
	ZSTD_ldm_insertEntry(ldmState, hash, entry, ldmParams);
	}
	}

	/** ZSTD_ldm_countBackwardsMatch() :
	* Returns the number of bytes that match backwards before pIn and pMatch.
	*
	* We count only bytes where pMatch >= pBase and pIn >= pAnchor. */
	static size_t ZSTD_ldm_countBackwardsMatch(
	const BYTE* pIn, const BYTE* pAnchor,
	const BYTE* pMatch, const BYTE* pBase)
	{
	size_t matchLength = 0;
	while (pIn > pAnchor && pMatch > pBase && pIn[-1] == pMatch[-1]) {
	pIn--;
	pMatch--;
	matchLength++;
	}
	return matchLength;
	}

	/** ZSTD_ldm_fillFastTables() :
	*
	* Fills the relevant tables for the ZSTD_fast and ZSTD_dfast strategies.
	* This is similar to ZSTD_loadDictionaryContent.
	*
	* The tables for the other strategies are filled within their
	* block compressors. */
	static size_t ZSTD_ldm_fillFastTables(ZSTD_matchState_t* ms,
	void const* end)
	{
	const BYTE* const iend = (const BYTE*)end;

	switch(ms->cParams.strategy)
	{
	case ZSTD_fast:
	ZSTD_fillHashTable(ms, iend, ZSTD_dtlm_fast);
	break;

	case ZSTD_dfast:
	ZSTD_fillDoubleHashTable(ms, iend, ZSTD_dtlm_fast);
	break;

	case ZSTD_greedy:
	case ZSTD_lazy:
	case ZSTD_lazy2:
	case ZSTD_btlazy2:
	case ZSTD_btopt:
	case ZSTD_btultra:
	case ZSTD_btultra2:
	break;
	default:
	assert(0); /* not possible : not a valid strategy id */
	}

	return 0;
	}

	/** ZSTD_ldm_fillLdmHashTable() :
	*
	* Fills hashTable from (lastHashed + 1) to iend (non-inclusive).
	* lastHash is the rolling hash that corresponds to lastHashed.
	*
	* Returns the rolling hash corresponding to position iend-1. */
	static U64 ZSTD_ldm_fillLdmHashTable(ldmState_t* state,
	U64 lastHash, const BYTE* lastHashed,
	const BYTE* iend, const BYTE* base,
	U32 hBits, ldmParams_t const ldmParams)
	{
	U64 rollingHash = lastHash;
	const BYTE* cur = lastHashed + 1;

	while (cur < iend) {
	rollingHash = ZSTD_rollingHash_rotate(rollingHash, cur[-1],
	cur[ldmParams.minMatchLength-1],
	state->hashPower);
	ZSTD_ldm_makeEntryAndInsertByTag(state,
	rollingHash, hBits,
	(U32)(cur - base), ldmParams);
	++cur;
	}
	return rollingHash;
	}

	void ZSTD_ldm_fillHashTable(
	ldmState_t* state, const BYTE* ip,
	const BYTE* iend, ldmParams_t const* params)
	{
	DEBUGLOG(5, "ZSTD_ldm_fillHashTable");
	if ((size_t)(iend - ip) >= params->minMatchLength) {
	U64 startingHash = ZSTD_rollingHash_compute(ip, params->minMatchLength);
	ZSTD_ldm_fillLdmHashTable(
	state, startingHash, ip, iend - params->minMatchLength, state->window.base,
	params->hashLog - params->bucketSizeLog,
	*params);
	}
	}


	/** ZSTD_ldm_limitTableUpdate() :
	*
	* Sets cctx->nextToUpdate to a position corresponding closer to anchor
	* if it is far way
	* (after a long match, only update tables a limited amount). */
	static void ZSTD_ldm_limitTableUpdate(ZSTD_matchState_t* ms, const BYTE* anchor)
	{
	U32 const current = (U32)(anchor - ms->window.base);
	if (current > ms->nextToUpdate + 1024) {
	ms->nextToUpdate =
	current - MIN(512, current - ms->nextToUpdate - 1024);
	}
	}

	static size_t ZSTD_ldm_generateSequences_internal(
	ldmState_t* ldmState, rawSeqStore_t* rawSeqStore,
	ldmParams_t const* params, void const* src, size_t srcSize)
	{
	/* LDM parameters */
	int const extDict = ZSTD_window_hasExtDict(ldmState->window);
	U32 const minMatchLength = params->minMatchLength;
	U64 const hashPower = ldmState->hashPower;
	U32 const hBits = params->hashLog - params->bucketSizeLog;
	U32 const ldmBucketSize = 1U << params->bucketSizeLog;
	U32 const hashRateLog = params->hashRateLog;
	U32 const ldmTagMask = (1U << params->hashRateLog) - 1;
	/* Prefix and extDict parameters */
	U32 const dictLimit = ldmState->window.dictLimit;
	U32 const lowestIndex = extDict ? ldmState->window.lowLimit : dictLimit;
	BYTE const* const base = ldmState->window.base;
	BYTE const* const dictBase = extDict ? ldmState->window.dictBase : NULL;
	BYTE const* const dictStart = extDict ? dictBase + lowestIndex : NULL;
	BYTE const* const dictEnd = extDict ? dictBase + dictLimit : NULL;
	BYTE const* const lowPrefixPtr = base + dictLimit;
	/* Input bounds */
	BYTE const* const istart = (BYTE const*)src;
	BYTE const* const iend = istart + srcSize;
	BYTE const* const ilimit = iend - MAX(minMatchLength, HASH_READ_SIZE);
	/* Input positions */
	BYTE const* anchor = istart;
	BYTE const* ip = istart;
	/* Rolling hash */
	BYTE const* lastHashed = NULL;
	U64 rollingHash = 0;

	while (ip <= ilimit) {
	size_t mLength;
	U32 const current = (U32)(ip - base);
	size_t forwardMatchLength = 0, backwardMatchLength = 0;
	ldmEntry_t* bestEntry = NULL;
	if (ip != istart) {
	rollingHash = ZSTD_rollingHash_rotate(rollingHash, lastHashed[0],
	lastHashed[minMatchLength],
	hashPower);
	} else {
	rollingHash = ZSTD_rollingHash_compute(ip, minMatchLength);
	}
	lastHashed = ip;

	/* Do not insert and do not look for a match */
	if (ZSTD_ldm_getTag(rollingHash, hBits, hashRateLog) != ldmTagMask) {
	ip++;
	continue;
	}

	/* Get the best entry and compute the match lengths */
	{
	ldmEntry_t* const bucket =
	ZSTD_ldm_getBucket(ldmState,
	ZSTD_ldm_getSmallHash(rollingHash, hBits),
	*params);
	ldmEntry_t* cur;
	size_t bestMatchLength = 0;
	U32 const checksum = ZSTD_ldm_getChecksum(rollingHash, hBits);

	for (cur = bucket; cur < bucket + ldmBucketSize; ++cur) {
	size_t curForwardMatchLength, curBackwardMatchLength,
	curTotalMatchLength;
	if (cur->checksum != checksum \|\| cur->offset <= lowestIndex) {
	continue;
	}
	if (extDict) {
	BYTE const* const curMatchBase =
	cur->offset < dictLimit ? dictBase : base;
	BYTE const* const pMatch = curMatchBase + cur->offset;
	BYTE const* const matchEnd =
	cur->offset < dictLimit ? dictEnd : iend;
	BYTE const* const lowMatchPtr =
	cur->offset < dictLimit ? dictStart : lowPrefixPtr;

	curForwardMatchLength = ZSTD_count_2segments(
	ip, pMatch, iend,
	matchEnd, lowPrefixPtr);
	if (curForwardMatchLength < minMatchLength) {
	continue;
	}
	curBackwardMatchLength =
	ZSTD_ldm_countBackwardsMatch(ip, anchor, pMatch,
	lowMatchPtr);
	curTotalMatchLength = curForwardMatchLength +
	curBackwardMatchLength;
	} else { /* !extDict */
	BYTE const* const pMatch = base + cur->offset;
	curForwardMatchLength = ZSTD_count(ip, pMatch, iend);
	if (curForwardMatchLength < minMatchLength) {
	continue;
	}
	curBackwardMatchLength =
	ZSTD_ldm_countBackwardsMatch(ip, anchor, pMatch,
	lowPrefixPtr);
	curTotalMatchLength = curForwardMatchLength +
	curBackwardMatchLength;
	}

	if (curTotalMatchLength > bestMatchLength) {
	bestMatchLength = curTotalMatchLength;
	forwardMatchLength = curForwardMatchLength;
	backwardMatchLength = curBackwardMatchLength;
	bestEntry = cur;
	}
	}
	}

	/* No match found -- continue searching */
	if (bestEntry == NULL) {
	ZSTD_ldm_makeEntryAndInsertByTag(ldmState, rollingHash,
	hBits, current,
	*params);
	ip++;
	continue;
	}

	/* Match found */
	mLength = forwardMatchLength + backwardMatchLength;
	ip -= backwardMatchLength;

	{
	/* Store the sequence:
	* ip = current - backwardMatchLength
	* The match is at (bestEntry->offset - backwardMatchLength)
	*/
	U32 const matchIndex = bestEntry->offset;
	U32 const offset = current - matchIndex;
	rawSeq* const seq = rawSeqStore->seq + rawSeqStore->size;

	/* Out of sequence storage */
	if (rawSeqStore->size == rawSeqStore->capacity)
	return ERROR(dstSize_tooSmall);
	seq->litLength = (U32)(ip - anchor);
	seq->matchLength = (U32)mLength;
	seq->offset = offset;
	rawSeqStore->size++;
	}

	/* Insert the current entry into the hash table */
	ZSTD_ldm_makeEntryAndInsertByTag(ldmState, rollingHash, hBits,
	(U32)(lastHashed - base),
	*params);

	assert(ip + backwardMatchLength == lastHashed);

	/* Fill the hash table from lastHashed+1 to ip+mLength*/
	/* Heuristic: don't need to fill the entire table at end of block */
	if (ip + mLength <= ilimit) {
	rollingHash = ZSTD_ldm_fillLdmHashTable(
	ldmState, rollingHash, lastHashed,
	ip + mLength, base, hBits, *params);
	lastHashed = ip + mLength - 1;
	}
	ip += mLength;
	anchor = ip;
	}
	return iend - anchor;
	}

	/*! ZSTD_ldm_reduceTable() :
	* reduce table indexes by `reducerValue` */
	static void ZSTD_ldm_reduceTable(ldmEntry_t* const table, U32 const size,
	U32 const reducerValue)
	{
	U32 u;
	for (u = 0; u < size; u++) {
	if (table[u].offset < reducerValue) table[u].offset = 0;
	else table[u].offset -= reducerValue;
	}
	}

	size_t ZSTD_ldm_generateSequences(
	ldmState_t* ldmState, rawSeqStore_t* sequences,
	ldmParams_t const* params, void const* src, size_t srcSize)
	{
	U32 const maxDist = 1U << params->windowLog;
	BYTE const* const istart = (BYTE const*)src;
	BYTE const* const iend = istart + srcSize;
	size_t const kMaxChunkSize = 1 << 20;
	size_t const nbChunks = (srcSize / kMaxChunkSize) + ((srcSize % kMaxChunkSize) != 0);
	size_t chunk;
	size_t leftoverSize = 0;

	assert(ZSTD_CHUNKSIZE_MAX >= kMaxChunkSize);
	/* Check that ZSTD_window_update() has been called for this chunk prior
	* to passing it to this function.
	*/
	assert(ldmState->window.nextSrc >= (BYTE const*)src + srcSize);
	/* The input could be very large (in zstdmt), so it must be broken up into
	* chunks to enforce the maximum distance and handle overflow correction.
	*/
	assert(sequences->pos <= sequences->size);
	assert(sequences->size <= sequences->capacity);
	for (chunk = 0; chunk < nbChunks && sequences->size < sequences->capacity; ++chunk) {
	BYTE const* const chunkStart = istart + chunk * kMaxChunkSize;
	size_t const remaining = (size_t)(iend - chunkStart);
	BYTE const *const chunkEnd =
	(remaining < kMaxChunkSize) ? iend : chunkStart + kMaxChunkSize;
	size_t const chunkSize = chunkEnd - chunkStart;
	size_t newLeftoverSize;
	size_t const prevSize = sequences->size;

	assert(chunkStart < iend);
	/* 1. Perform overflow correction if necessary. */
	if (ZSTD_window_needOverflowCorrection(ldmState->window, chunkEnd)) {
	U32 const ldmHSize = 1U << params->hashLog;
	U32 const correction = ZSTD_window_correctOverflow(
	&ldmState->window, /* cycleLog */ 0, maxDist, chunkStart);
	ZSTD_ldm_reduceTable(ldmState->hashTable, ldmHSize, correction);
	/* invalidate dictionaries on overflow correction */
	ldmState->loadedDictEnd = 0;
	}
	/* 2. We enforce the maximum offset allowed.
	*
	* kMaxChunkSize should be small enough that we don't lose too much of
	* the window through early invalidation.
	* TODO: * Test the chunk size.
	* * Try invalidation after the sequence generation and test the
	* the offset against maxDist directly.
	*
	* NOTE: Because of dictionaries + sequence splitting we MUST make sure
	* that any offset used is valid at the END of the sequence, since it may
	* be split into two sequences. This condition holds when using
	* ZSTD_window_enforceMaxDist(), but if we move to checking offsets
	* against maxDist directly, we'll have to carefully handle that case.
	*/
	ZSTD_window_enforceMaxDist(&ldmState->window, chunkEnd, maxDist, &ldmState->loadedDictEnd, NULL);
	/* 3. Generate the sequences for the chunk, and get newLeftoverSize. */
	newLeftoverSize = ZSTD_ldm_generateSequences_internal(
	ldmState, sequences, params, chunkStart, chunkSize);
	if (ZSTD_isError(newLeftoverSize))
	return newLeftoverSize;
	/* 4. We add the leftover literals from previous iterations to the first
	* newly generated sequence, or add the `newLeftoverSize` if none are
	* generated.
	*/
	/* Prepend the leftover literals from the last call */
	if (prevSize < sequences->size) {
	sequences->seq[prevSize].litLength += (U32)leftoverSize;
	leftoverSize = newLeftoverSize;
	} else {
	assert(newLeftoverSize == chunkSize);
	leftoverSize += chunkSize;
	}
	}
	return 0;
	}

	void ZSTD_ldm_skipSequences(rawSeqStore_t* rawSeqStore, size_t srcSize, U32 const minMatch) {
	while (srcSize > 0 && rawSeqStore->pos < rawSeqStore->size) {
	rawSeq* seq = rawSeqStore->seq + rawSeqStore->pos;
	if (srcSize <= seq->litLength) {
	/* Skip past srcSize literals */
	seq->litLength -= (U32)srcSize;
	return;
	}
	srcSize -= seq->litLength;
	seq->litLength = 0;
	if (srcSize < seq->matchLength) {
	/* Skip past the first srcSize of the match */
	seq->matchLength -= (U32)srcSize;
	if (seq->matchLength < minMatch) {
	/* The match is too short, omit it */
	if (rawSeqStore->pos + 1 < rawSeqStore->size) {
	seq[1].litLength += seq[0].matchLength;
	}
	rawSeqStore->pos++;
	}
	return;
	}
	srcSize -= seq->matchLength;
	seq->matchLength = 0;
	rawSeqStore->pos++;
	}
	}

	/**
	* If the sequence length is longer than remaining then the sequence is split
	* between this block and the next.
	*
	* Returns the current sequence to handle, or if the rest of the block should
	* be literals, it returns a sequence with offset == 0.
	*/
	static rawSeq maybeSplitSequence(rawSeqStore_t* rawSeqStore,
	U32 const remaining, U32 const minMatch)
	{
	rawSeq sequence = rawSeqStore->seq[rawSeqStore->pos];
	assert(sequence.offset > 0);
	/* Likely: No partial sequence */
	if (remaining >= sequence.litLength + sequence.matchLength) {
	rawSeqStore->pos++;
	return sequence;
	}
	/* Cut the sequence short (offset == 0 ==> rest is literals). */
	if (remaining <= sequence.litLength) {
	sequence.offset = 0;
	} else if (remaining < sequence.litLength + sequence.matchLength) {
	sequence.matchLength = remaining - sequence.litLength;
	if (sequence.matchLength < minMatch) {
	sequence.offset = 0;
	}
	}
	/* Skip past `remaining` bytes for the future sequences. */
	ZSTD_ldm_skipSequences(rawSeqStore, remaining, minMatch);
	return sequence;
	}

	size_t ZSTD_ldm_blockCompress(rawSeqStore_t* rawSeqStore,
	ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
	void const* src, size_t srcSize)
	{
	const ZSTD_compressionParameters* const cParams = &ms->cParams;
	unsigned const minMatch = cParams->minMatch;
	ZSTD_blockCompressor const blockCompressor =
	ZSTD_selectBlockCompressor(cParams->strategy, ZSTD_matchState_dictMode(ms));
	/* Input bounds */
	BYTE const* const istart = (BYTE const*)src;
	BYTE const* const iend = istart + srcSize;
	/* Input positions */
	BYTE const* ip = istart;

	DEBUGLOG(5, "ZSTD_ldm_blockCompress: srcSize=%zu", srcSize);
	assert(rawSeqStore->pos <= rawSeqStore->size);
	assert(rawSeqStore->size <= rawSeqStore->capacity);
	/* Loop through each sequence and apply the block compressor to the lits */
	while (rawSeqStore->pos < rawSeqStore->size && ip < iend) {
	/* maybeSplitSequence updates rawSeqStore->pos */
	rawSeq const sequence = maybeSplitSequence(rawSeqStore,
	(U32)(iend - ip), minMatch);
	int i;
	/* End signal */
	if (sequence.offset == 0)
	break;

	assert(ip + sequence.litLength + sequence.matchLength <= iend);

	/* Fill tables for block compressor */
	ZSTD_ldm_limitTableUpdate(ms, ip);
	ZSTD_ldm_fillFastTables(ms, ip);
	/* Run the block compressor */
	DEBUGLOG(5, "pos %u : calling block compressor on segment of size %u", (unsigned)(ip-istart), sequence.litLength);
	{
	size_t const newLitLength =
	blockCompressor(ms, seqStore, rep, ip, sequence.litLength);
	ip += sequence.litLength;
	/* Update the repcodes */
	for (i = ZSTD_REP_NUM - 1; i > 0; i--)
	rep[i] = rep[i-1];
	rep[0] = sequence.offset;
	/* Store the sequence */
	ZSTD_storeSeq(seqStore, newLitLength, ip - newLitLength, iend,
	sequence.offset + ZSTD_REP_MOVE,
	sequence.matchLength - MINMATCH);
	ip += sequence.matchLength;
	}
	}
	/* Fill the tables for the block compressor */
	ZSTD_ldm_limitTableUpdate(ms, ip);
	ZSTD_ldm_fillFastTables(ms, ip);
	/* Compress the last literals */
	return blockCompressor(ms, seqStore, rep, ip, iend - ip);
	}
	/** ended inlining compress/zstd_ldm.c **/
	/** start inlining compress/zstd_opt.c **/
	/*
	* Copyright (c) 2016-2020, Przemyslaw Skibinski, Yann Collet, Facebook, Inc.
	* All rights reserved.
	*
	* This source code is licensed under both the BSD-style license (found in the
	* LICENSE file in the root directory of this source tree) and the GPLv2 (found
	* in the COPYING file in the root directory of this source tree).
	* You may select, at your option, one of the above-listed licenses.
	*/

	/** skipping file: zstd_compress_internal.h **/
	/** skipping file: hist.h **/
	/** skipping file: zstd_opt.h **/


	#define ZSTD_LITFREQ_ADD 2 /* scaling factor for litFreq, so that frequencies adapt faster to new stats */
	#define ZSTD_FREQ_DIV 4 /* log factor when using previous stats to init next stats */
	#define ZSTD_MAX_PRICE (1<<30)

	#define ZSTD_PREDEF_THRESHOLD 1024 /* if srcSize < ZSTD_PREDEF_THRESHOLD, symbols' cost is assumed static, directly determined by pre-defined distributions */


	/-************************************
	* Price functions for optimal parser
	***************************************/

	#if 0 /* approximation at bit level */
	# define BITCOST_ACCURACY 0
	# define BITCOST_MULTIPLIER (1 << BITCOST_ACCURACY)
	# define WEIGHT(stat) ((void)opt, ZSTD_bitWeight(stat))
	#elif 0 /* fractional bit accuracy */
	# define BITCOST_ACCURACY 8
	# define BITCOST_MULTIPLIER (1 << BITCOST_ACCURACY)
	# define WEIGHT(stat,opt) ((void)opt, ZSTD_fracWeight(stat))
	#else /* opt==approx, ultra==accurate */
	# define BITCOST_ACCURACY 8
	# define BITCOST_MULTIPLIER (1 << BITCOST_ACCURACY)
	# define WEIGHT(stat,opt) (opt ? ZSTD_fracWeight(stat) : ZSTD_bitWeight(stat))
	#endif

	MEM_STATIC U32 ZSTD_bitWeight(U32 stat)
	{
	return (ZSTD_highbit32(stat+1) * BITCOST_MULTIPLIER);
	}

	MEM_STATIC U32 ZSTD_fracWeight(U32 rawStat)
	{
	U32 const stat = rawStat + 1;
	U32 const hb = ZSTD_highbit32(stat);
	U32 const BWeight = hb * BITCOST_MULTIPLIER;
	U32 const FWeight = (stat << BITCOST_ACCURACY) >> hb;
	U32 const weight = BWeight + FWeight;
	assert(hb + BITCOST_ACCURACY < 31);
	return weight;
	}

	#if (DEBUGLEVEL>=2)
	/* debugging function,
	* @return price in bytes as fractional value
	* for debug messages only */
	MEM_STATIC double ZSTD_fCost(U32 price)
	{
	return (double)price / (BITCOST_MULTIPLIER*8);
	}
	#endif

	static int ZSTD_compressedLiterals(optState_t const* const optPtr)
	{
	return optPtr->literalCompressionMode != ZSTD_lcm_uncompressed;
	}

	static void ZSTD_setBasePrices(optState_t* optPtr, int optLevel)
	{
	if (ZSTD_compressedLiterals(optPtr))
	optPtr->litSumBasePrice = WEIGHT(optPtr->litSum, optLevel);
	optPtr->litLengthSumBasePrice = WEIGHT(optPtr->litLengthSum, optLevel);
	optPtr->matchLengthSumBasePrice = WEIGHT(optPtr->matchLengthSum, optLevel);
	optPtr->offCodeSumBasePrice = WEIGHT(optPtr->offCodeSum, optLevel);
	}


	/* ZSTD_downscaleStat() :
	* reduce all elements in table by a factor 2^(ZSTD_FREQ_DIV+malus)
	* return the resulting sum of elements */
	static U32 ZSTD_downscaleStat(unsigned* table, U32 lastEltIndex, int malus)
	{
	U32 s, sum=0;
	DEBUGLOG(5, "ZSTD_downscaleStat (nbElts=%u)", (unsigned)lastEltIndex+1);
	assert(ZSTD_FREQ_DIV+malus > 0 && ZSTD_FREQ_DIV+malus < 31);
	for (s=0; s<lastEltIndex+1; s++) {
	table[s] = 1 + (table[s] >> (ZSTD_FREQ_DIV+malus));
	sum += table[s];
	}
	return sum;
	}

	/* ZSTD_rescaleFreqs() :
	* if first block (detected by optPtr->litLengthSum == 0) : init statistics
	* take hints from dictionary if there is one
	* or init from zero, using src for literals stats, or flat 1 for match symbols
	* otherwise downscale existing stats, to be used as seed for next block.
	*/
	static void
	ZSTD_rescaleFreqs(optState_t* const optPtr,
	const BYTE* const src, size_t const srcSize,
	int const optLevel)
	{
	int const compressedLiterals = ZSTD_compressedLiterals(optPtr);
	DEBUGLOG(5, "ZSTD_rescaleFreqs (srcSize=%u)", (unsigned)srcSize);
	optPtr->priceType = zop_dynamic;

	if (optPtr->litLengthSum == 0) { /* first block : init */
	if (srcSize <= ZSTD_PREDEF_THRESHOLD) { /* heuristic */
	DEBUGLOG(5, "(srcSize <= ZSTD_PREDEF_THRESHOLD) => zop_predef");
	optPtr->priceType = zop_predef;
	}

	assert(optPtr->symbolCosts != NULL);
	if (optPtr->symbolCosts->huf.repeatMode == HUF_repeat_valid) {
	/* huffman table presumed generated by dictionary */
	optPtr->priceType = zop_dynamic;

	if (compressedLiterals) {
	unsigned lit;
	assert(optPtr->litFreq != NULL);
	optPtr->litSum = 0;
	for (lit=0; lit<=MaxLit; lit++) {
	U32 const scaleLog = 11; /* scale to 2K */
	U32 const bitCost = HUF_getNbBits(optPtr->symbolCosts->huf.CTable, lit);
	assert(bitCost <= scaleLog);
	optPtr->litFreq[lit] = bitCost ? 1 << (scaleLog-bitCost) : 1 /minimum to calculate cost/;
	optPtr->litSum += optPtr->litFreq[lit];
	} }

	{ unsigned ll;
	FSE_CState_t llstate;
	FSE_initCState(&llstate, optPtr->symbolCosts->fse.litlengthCTable);
	optPtr->litLengthSum = 0;
	for (ll=0; ll<=MaxLL; ll++) {
	U32 const scaleLog = 10; /* scale to 1K */
	U32 const bitCost = FSE_getMaxNbBits(llstate.symbolTT, ll);
	assert(bitCost < scaleLog);
	optPtr->litLengthFreq[ll] = bitCost ? 1 << (scaleLog-bitCost) : 1 /minimum to calculate cost/;
	optPtr->litLengthSum += optPtr->litLengthFreq[ll];
	} }

	{ unsigned ml;
	FSE_CState_t mlstate;
	FSE_initCState(&mlstate, optPtr->symbolCosts->fse.matchlengthCTable);
	optPtr->matchLengthSum = 0;
	for (ml=0; ml<=MaxML; ml++) {
	U32 const scaleLog = 10;
	U32 const bitCost = FSE_getMaxNbBits(mlstate.symbolTT, ml);
	assert(bitCost < scaleLog);
	optPtr->matchLengthFreq[ml] = bitCost ? 1 << (scaleLog-bitCost) : 1 /minimum to calculate cost/;
	optPtr->matchLengthSum += optPtr->matchLengthFreq[ml];
	} }

	{ unsigned of;
	FSE_CState_t ofstate;
	FSE_initCState(&ofstate, optPtr->symbolCosts->fse.offcodeCTable);
	optPtr->offCodeSum = 0;
	for (of=0; of<=MaxOff; of++) {
	U32 const scaleLog = 10;
	U32 const bitCost = FSE_getMaxNbBits(ofstate.symbolTT, of);
	assert(bitCost < scaleLog);
	optPtr->offCodeFreq[of] = bitCost ? 1 << (scaleLog-bitCost) : 1 /minimum to calculate cost/;
	optPtr->offCodeSum += optPtr->offCodeFreq[of];
	} }

	} else { /* not a dictionary */

	assert(optPtr->litFreq != NULL);
	if (compressedLiterals) {
	unsigned lit = MaxLit;
	HIST_count_simple(optPtr->litFreq, &lit, src, srcSize); /* use raw first block to init statistics */
	optPtr->litSum = ZSTD_downscaleStat(optPtr->litFreq, MaxLit, 1);
	}

	{ unsigned ll;
	for (ll=0; ll<=MaxLL; ll++)
	optPtr->litLengthFreq[ll] = 1;
	}
	optPtr->litLengthSum = MaxLL+1;

	{ unsigned ml;
	for (ml=0; ml<=MaxML; ml++)
	optPtr->matchLengthFreq[ml] = 1;
	}
	optPtr->matchLengthSum = MaxML+1;

	{ unsigned of;
	for (of=0; of<=MaxOff; of++)
	optPtr->offCodeFreq[of] = 1;
	}
	optPtr->offCodeSum = MaxOff+1;

	}

	} else { /* new block : re-use previous statistics, scaled down */

	if (compressedLiterals)
	optPtr->litSum = ZSTD_downscaleStat(optPtr->litFreq, MaxLit, 1);
	optPtr->litLengthSum = ZSTD_downscaleStat(optPtr->litLengthFreq, MaxLL, 0);
	optPtr->matchLengthSum = ZSTD_downscaleStat(optPtr->matchLengthFreq, MaxML, 0);
	optPtr->offCodeSum = ZSTD_downscaleStat(optPtr->offCodeFreq, MaxOff, 0);
	}

	ZSTD_setBasePrices(optPtr, optLevel);
	}

	/* ZSTD_rawLiteralsCost() :
	* price of literals (only) in specified segment (which length can be 0).
	* does not include price of literalLength symbol */
	static U32 ZSTD_rawLiteralsCost(const BYTE* const literals, U32 const litLength,
	const optState_t* const optPtr,
	int optLevel)
	{
	if (litLength == 0) return 0;

	if (!ZSTD_compressedLiterals(optPtr))
	return (litLength << 3) * BITCOST_MULTIPLIER; /* Uncompressed - 8 bytes per literal. */

	if (optPtr->priceType == zop_predef)
	return (litLength6) BITCOST_MULTIPLIER; /* 6 bit per literal - no statistic used */

	/* dynamic statistics */
	{ U32 price = litLength * optPtr->litSumBasePrice;
	U32 u;
	for (u=0; u < litLength; u++) {
	assert(WEIGHT(optPtr->litFreq[literals[u]], optLevel) <= optPtr->litSumBasePrice); /* literal cost should never be negative */
	price -= WEIGHT(optPtr->litFreq[literals[u]], optLevel);
	}
	return price;
	}
	}

	/* ZSTD_litLengthPrice() :
	* cost of literalLength symbol */
	static U32 ZSTD_litLengthPrice(U32 const litLength, const optState_t* const optPtr, int optLevel)
	{
	if (optPtr->priceType == zop_predef) return WEIGHT(litLength, optLevel);

	/* dynamic statistics */
	{ U32 const llCode = ZSTD_LLcode(litLength);
	return (LL_bits[llCode] * BITCOST_MULTIPLIER)
	+ optPtr->litLengthSumBasePrice
	- WEIGHT(optPtr->litLengthFreq[llCode], optLevel);
	}
	}

	/* ZSTD_getMatchPrice() :
	* Provides the cost of the match part (offset + matchLength) of a sequence
	* Must be combined with ZSTD_fullLiteralsCost() to get the full cost of a sequence.
	* optLevel: when <2, favors small offset for decompression speed (improved cache efficiency) */
	FORCE_INLINE_TEMPLATE U32
	ZSTD_getMatchPrice(U32 const offset,
	U32 const matchLength,
	const optState_t* const optPtr,
	int const optLevel)
	{
	U32 price;
	U32 const offCode = ZSTD_highbit32(offset+1);
	U32 const mlBase = matchLength - MINMATCH;
	assert(matchLength >= MINMATCH);

	if (optPtr->priceType == zop_predef) /* fixed scheme, do not use statistics */
	return WEIGHT(mlBase, optLevel) + ((16 + offCode) * BITCOST_MULTIPLIER);

	/* dynamic statistics */
	price = (offCode * BITCOST_MULTIPLIER) + (optPtr->offCodeSumBasePrice - WEIGHT(optPtr->offCodeFreq[offCode], optLevel));
	if ((optLevel<2) /static/ && offCode >= 20)
	price += (offCode-19)2 BITCOST_MULTIPLIER; /* handicap for long distance offsets, favor decompression speed */

	/* match Length */
	{ U32 const mlCode = ZSTD_MLcode(mlBase);
	price += (ML_bits[mlCode] * BITCOST_MULTIPLIER) + (optPtr->matchLengthSumBasePrice - WEIGHT(optPtr->matchLengthFreq[mlCode], optLevel));
	}

	price += BITCOST_MULTIPLIER / 5; /* heuristic : make matches a bit more costly to favor less sequences -> faster decompression speed */

	DEBUGLOG(8, "ZSTD_getMatchPrice(ml:%u) = %u", matchLength, price);
	return price;
	}

	/* ZSTD_updateStats() :
	* assumption : literals + litLengtn <= iend */
	static void ZSTD_updateStats(optState_t* const optPtr,
	U32 litLength, const BYTE* literals,
	U32 offsetCode, U32 matchLength)
	{
	/* literals */
	if (ZSTD_compressedLiterals(optPtr)) {
	U32 u;
	for (u=0; u < litLength; u++)
	optPtr->litFreq[literals[u]] += ZSTD_LITFREQ_ADD;
	optPtr->litSum += litLength*ZSTD_LITFREQ_ADD;
	}

	/* literal Length */
	{ U32 const llCode = ZSTD_LLcode(litLength);
	optPtr->litLengthFreq[llCode]++;
	optPtr->litLengthSum++;
	}

	/* match offset code (0-2=>repCode; 3+=>offset+2) */
	{ U32 const offCode = ZSTD_highbit32(offsetCode+1);
	assert(offCode <= MaxOff);
	optPtr->offCodeFreq[offCode]++;
	optPtr->offCodeSum++;
	}

	/* match Length */
	{ U32 const mlBase = matchLength - MINMATCH;
	U32 const mlCode = ZSTD_MLcode(mlBase);
	optPtr->matchLengthFreq[mlCode]++;
	optPtr->matchLengthSum++;
	}
	}


	/* ZSTD_readMINMATCH() :
	* function safe only for comparisons
	* assumption : memPtr must be at least 4 bytes before end of buffer */
	MEM_STATIC U32 ZSTD_readMINMATCH(const void* memPtr, U32 length)
	{
	switch (length)
	{
	default :
	case 4 : return MEM_read32(memPtr);
	case 3 : if (MEM_isLittleEndian())
	return MEM_read32(memPtr)<<8;
	else
	return MEM_read32(memPtr)>>8;
	}
	}


	/* Update hashTable3 up to ip (excluded)
	Assumption : always within prefix (i.e. not within extDict) */
	static U32 ZSTD_insertAndFindFirstIndexHash3 (ZSTD_matchState_t* ms,
	U32* nextToUpdate3,
	const BYTE* const ip)
	{
	U32* const hashTable3 = ms->hashTable3;
	U32 const hashLog3 = ms->hashLog3;
	const BYTE* const base = ms->window.base;
	U32 idx = *nextToUpdate3;
	U32 const target = (U32)(ip - base);
	size_t const hash3 = ZSTD_hash3Ptr(ip, hashLog3);
	assert(hashLog3 > 0);

	while(idx < target) {
	hashTable3[ZSTD_hash3Ptr(base+idx, hashLog3)] = idx;
	idx++;
	}

	*nextToUpdate3 = target;
	return hashTable3[hash3];
	}


	/-************************************
	* Binary Tree search
	***************************************/
	/** ZSTD_insertBt1() : add one or multiple positions to tree.
	* ip : assumed <= iend-8 .
	* @return : nb of positions added */
	static U32 ZSTD_insertBt1(
	ZSTD_matchState_t* ms,
	const BYTE* const ip, const BYTE* const iend,
	U32 const mls, const int extDict)
	{
	const ZSTD_compressionParameters* const cParams = &ms->cParams;
	U32* const hashTable = ms->hashTable;
	U32 const hashLog = cParams->hashLog;
	size_t const h = ZSTD_hashPtr(ip, hashLog, mls);
	U32* const bt = ms->chainTable;
	U32 const btLog = cParams->chainLog - 1;
	U32 const btMask = (1 << btLog) - 1;
	U32 matchIndex = hashTable[h];
	size_t commonLengthSmaller=0, commonLengthLarger=0;
	const BYTE* const base = ms->window.base;
	const BYTE* const dictBase = ms->window.dictBase;
	const U32 dictLimit = ms->window.dictLimit;
	const BYTE* const dictEnd = dictBase + dictLimit;
	const BYTE* const prefixStart = base + dictLimit;
	const BYTE* match;
	const U32 current = (U32)(ip-base);
	const U32 btLow = btMask >= current ? 0 : current - btMask;
	U32* smallerPtr = bt + 2*(current&btMask);
	U32* largerPtr = smallerPtr + 1;
	U32 dummy32; /* to be nullified at the end */
	U32 const windowLow = ms->window.lowLimit;
	U32 matchEndIdx = current+8+1;
	size_t bestLength = 8;
	U32 nbCompares = 1U << cParams->searchLog;
	#ifdef ZSTD_C_PREDICT
	U32 predictedSmall = (bt + 2((current-1)&btMask) + 0);
	U32 predictedLarge = (bt + 2((current-1)&btMask) + 1);
	predictedSmall += (predictedSmall>0);
	predictedLarge += (predictedLarge>0);
	#endif /* ZSTD_C_PREDICT */

	DEBUGLOG(8, "ZSTD_insertBt1 (%u)", current);

	assert(ip <= iend-8); /* required for h calculation */
	hashTable[h] = current; /* Update Hash Table */

	assert(windowLow > 0);
	while (nbCompares-- && (matchIndex >= windowLow)) {
	U32* const nextPtr = bt + 2*(matchIndex & btMask);
	size_t matchLength = MIN(commonLengthSmaller, commonLengthLarger); /* guaranteed minimum nb of common bytes */
	assert(matchIndex < current);

	#ifdef ZSTD_C_PREDICT /* note : can create issues when hlog small <= 11 */
	const U32* predictPtr = bt + 2((matchIndex-1) & btMask); / written this way, as bt is a roll buffer */
	if (matchIndex == predictedSmall) {
	/* no need to check length, result known */
	*smallerPtr = matchIndex;
	if (matchIndex <= btLow) { smallerPtr=&dummy32; break; } /* beyond tree size, stop the search */
	smallerPtr = nextPtr+1; /* new "smaller" => larger of match */
	matchIndex = nextPtr[1]; /* new matchIndex larger than previous (closer to current) */
	predictedSmall = predictPtr[1] + (predictPtr[1]>0);
	continue;
	}
	if (matchIndex == predictedLarge) {
	*largerPtr = matchIndex;
	if (matchIndex <= btLow) { largerPtr=&dummy32; break; } /* beyond tree size, stop the search */
	largerPtr = nextPtr;
	matchIndex = nextPtr[0];
	predictedLarge = predictPtr[0] + (predictPtr[0]>0);
	continue;
	}
	#endif

	if (!extDict \|\| (matchIndex+matchLength >= dictLimit)) {
	assert(matchIndex+matchLength >= dictLimit); /* might be wrong if actually extDict */
	match = base + matchIndex;
	matchLength += ZSTD_count(ip+matchLength, match+matchLength, iend);
	} else {
	match = dictBase + matchIndex;
	matchLength += ZSTD_count_2segments(ip+matchLength, match+matchLength, iend, dictEnd, prefixStart);
	if (matchIndex+matchLength >= dictLimit)
	match = base + matchIndex; /* to prepare for next usage of match[matchLength] */
	}

	if (matchLength > bestLength) {
	bestLength = matchLength;
	if (matchLength > matchEndIdx - matchIndex)
	matchEndIdx = matchIndex + (U32)matchLength;
	}

	if (ip+matchLength == iend) { /* equal : no way to know if inf or sup */
	break; /* drop , to guarantee consistency ; miss a bit of compression, but other solutions can corrupt tree */
	}

	if (match[matchLength] < ip[matchLength]) { /* necessarily within buffer */
	/* match is smaller than current */
	smallerPtr = matchIndex; / update smaller idx */
	commonLengthSmaller = matchLength; /* all smaller will now have at least this guaranteed common length */
	if (matchIndex <= btLow) { smallerPtr=&dummy32; break; } /* beyond tree size, stop searching */
	smallerPtr = nextPtr+1; /* new "candidate" => larger than match, which was smaller than target */
	matchIndex = nextPtr[1]; /* new matchIndex, larger than previous and closer to current */
	} else {
	/* match is larger than current */
	*largerPtr = matchIndex;
	commonLengthLarger = matchLength;
	if (matchIndex <= btLow) { largerPtr=&dummy32; break; } /* beyond tree size, stop searching */
	largerPtr = nextPtr;
	matchIndex = nextPtr[0];
	} }

	smallerPtr = largerPtr = 0;
	{ U32 positions = 0;
	if (bestLength > 384) positions = MIN(192, (U32)(bestLength - 384)); /* speed optimization */
	assert(matchEndIdx > current + 8);
	return MAX(positions, matchEndIdx - (current + 8));
	}
	}

	FORCE_INLINE_TEMPLATE
	void ZSTD_updateTree_internal(
	ZSTD_matchState_t* ms,
	const BYTE* const ip, const BYTE* const iend,
	const U32 mls, const ZSTD_dictMode_e dictMode)
	{
	const BYTE* const base = ms->window.base;
	U32 const target = (U32)(ip - base);
	U32 idx = ms->nextToUpdate;
	DEBUGLOG(6, "ZSTD_updateTree_internal, from %u to %u (dictMode:%u)",
	idx, target, dictMode);

	while(idx < target) {
	U32 const forward = ZSTD_insertBt1(ms, base+idx, iend, mls, dictMode == ZSTD_extDict);
	assert(idx < (U32)(idx + forward));
	idx += forward;
	}
	assert((size_t)(ip - base) <= (size_t)(U32)(-1));
	assert((size_t)(iend - base) <= (size_t)(U32)(-1));
	ms->nextToUpdate = target;
	}

	void ZSTD_updateTree(ZSTD_matchState_t* ms, const BYTE* ip, const BYTE* iend) {
	ZSTD_updateTree_internal(ms, ip, iend, ms->cParams.minMatch, ZSTD_noDict);
	}

	FORCE_INLINE_TEMPLATE
	U32 ZSTD_insertBtAndGetAllMatches (
	ZSTD_match_t* matches, /* store result (found matches) in this table (presumed large enough) */
	ZSTD_matchState_t* ms,
	U32* nextToUpdate3,
	const BYTE* const ip, const BYTE* const iLimit, const ZSTD_dictMode_e dictMode,
	const U32 rep[ZSTD_REP_NUM],
	U32 const ll0, /* tells if associated literal length is 0 or not. This value must be 0 or 1 */
	const U32 lengthToBeat,
	U32 const mls /* template */)
	{
	const ZSTD_compressionParameters* const cParams = &ms->cParams;
	U32 const sufficient_len = MIN(cParams->targetLength, ZSTD_OPT_NUM -1);
	const BYTE* const base = ms->window.base;
	U32 const current = (U32)(ip-base);
	U32 const hashLog = cParams->hashLog;
	U32 const minMatch = (mls==3) ? 3 : 4;
	U32* const hashTable = ms->hashTable;
	size_t const h = ZSTD_hashPtr(ip, hashLog, mls);
	U32 matchIndex = hashTable[h];
	U32* const bt = ms->chainTable;
	U32 const btLog = cParams->chainLog - 1;
	U32 const btMask= (1U << btLog) - 1;
	size_t commonLengthSmaller=0, commonLengthLarger=0;
	const BYTE* const dictBase = ms->window.dictBase;
	U32 const dictLimit = ms->window.dictLimit;
	const BYTE* const dictEnd = dictBase + dictLimit;
	const BYTE* const prefixStart = base + dictLimit;
	U32 const btLow = (btMask >= current) ? 0 : current - btMask;
	U32 const windowLow = ZSTD_getLowestMatchIndex(ms, current, cParams->windowLog);
	U32 const matchLow = windowLow ? windowLow : 1;
	U32* smallerPtr = bt + 2*(current&btMask);
	U32* largerPtr = bt + 2*(current&btMask) + 1;
	U32 matchEndIdx = current+8+1; /* farthest referenced position of any match => detects repetitive patterns */
	U32 dummy32; /* to be nullified at the end */
	U32 mnum = 0;
	U32 nbCompares = 1U << cParams->searchLog;

	const ZSTD_matchState_t* dms = dictMode == ZSTD_dictMatchState ? ms->dictMatchState : NULL;
	const ZSTD_compressionParameters* const dmsCParams =
	dictMode == ZSTD_dictMatchState ? &dms->cParams : NULL;
	const BYTE* const dmsBase = dictMode == ZSTD_dictMatchState ? dms->window.base : NULL;
	const BYTE* const dmsEnd = dictMode == ZSTD_dictMatchState ? dms->window.nextSrc : NULL;
	U32 const dmsHighLimit = dictMode == ZSTD_dictMatchState ? (U32)(dmsEnd - dmsBase) : 0;
	U32 const dmsLowLimit = dictMode == ZSTD_dictMatchState ? dms->window.lowLimit : 0;
	U32 const dmsIndexDelta = dictMode == ZSTD_dictMatchState ? windowLow - dmsHighLimit : 0;
	U32 const dmsHashLog = dictMode == ZSTD_dictMatchState ? dmsCParams->hashLog : hashLog;
	U32 const dmsBtLog = dictMode == ZSTD_dictMatchState ? dmsCParams->chainLog - 1 : btLog;
	U32 const dmsBtMask = dictMode == ZSTD_dictMatchState ? (1U << dmsBtLog) - 1 : 0;
	U32 const dmsBtLow = dictMode == ZSTD_dictMatchState && dmsBtMask < dmsHighLimit - dmsLowLimit ? dmsHighLimit - dmsBtMask : dmsLowLimit;

	size_t bestLength = lengthToBeat-1;
	DEBUGLOG(8, "ZSTD_insertBtAndGetAllMatches: current=%u", current);

	/* check repCode */
	assert(ll0 <= 1); /* necessarily 1 or 0 */
	{ U32 const lastR = ZSTD_REP_NUM + ll0;
	U32 repCode;
	for (repCode = ll0; repCode < lastR; repCode++) {
	U32 const repOffset = (repCode==ZSTD_REP_NUM) ? (rep[0] - 1) : rep[repCode];
	U32 const repIndex = current - repOffset;
	U32 repLen = 0;
	assert(current >= dictLimit);
	if (repOffset-1 /* intentional overflow, discards 0 and -1 / < current-dictLimit) { / equivalent to `current > repIndex >= dictLimit` */
	/* We must validate the repcode offset because when we're using a dictionary the
	* valid offset range shrinks when the dictionary goes out of bounds.
	*/
	if ((repIndex >= windowLow) & (ZSTD_readMINMATCH(ip, minMatch) == ZSTD_readMINMATCH(ip - repOffset, minMatch))) {
	repLen = (U32)ZSTD_count(ip+minMatch, ip+minMatch-repOffset, iLimit) + minMatch;
	}
	} else { /* repIndex < dictLimit \|\| repIndex >= current */
	const BYTE* const repMatch = dictMode == ZSTD_dictMatchState ?
	dmsBase + repIndex - dmsIndexDelta :
	dictBase + repIndex;
	assert(current >= windowLow);
	if ( dictMode == ZSTD_extDict
	&& ( ((repOffset-1) /intentional overflow/ < current - windowLow) /* equivalent to `current > repIndex >= windowLow` */
	& (((U32)((dictLimit-1) - repIndex) >= 3) ) /* intentional overflow : do not test positions overlapping 2 memory segments */)
	&& (ZSTD_readMINMATCH(ip, minMatch) == ZSTD_readMINMATCH(repMatch, minMatch)) ) {
	repLen = (U32)ZSTD_count_2segments(ip+minMatch, repMatch+minMatch, iLimit, dictEnd, prefixStart) + minMatch;
	}
	if (dictMode == ZSTD_dictMatchState
	&& ( ((repOffset-1) /intentional overflow/ < current - (dmsLowLimit + dmsIndexDelta)) /* equivalent to `current > repIndex >= dmsLowLimit` */
	& ((U32)((dictLimit-1) - repIndex) >= 3) ) /* intentional overflow : do not test positions overlapping 2 memory segments */
	&& (ZSTD_readMINMATCH(ip, minMatch) == ZSTD_readMINMATCH(repMatch, minMatch)) ) {
	repLen = (U32)ZSTD_count_2segments(ip+minMatch, repMatch+minMatch, iLimit, dmsEnd, prefixStart) + minMatch;
	} }
	/* save longer solution */
	if (repLen > bestLength) {
	DEBUGLOG(8, "found repCode %u (ll0:%u, offset:%u) of length %u",
	repCode, ll0, repOffset, repLen);
	bestLength = repLen;
	matches[mnum].off = repCode - ll0;
	matches[mnum].len = (U32)repLen;
	mnum++;
	if ( (repLen > sufficient_len)
	\| (ip+repLen == iLimit) ) { /* best possible */
	return mnum;
	} } } }

	/* HC3 match finder */
	if ((mls == 3) /static/ && (bestLength < mls)) {
	U32 const matchIndex3 = ZSTD_insertAndFindFirstIndexHash3(ms, nextToUpdate3, ip);
	if ((matchIndex3 >= matchLow)
	& (current - matchIndex3 < (1<<18)) /heuristic : longer distance likely too expensive/ ) {
	size_t mlen;
	if ((dictMode == ZSTD_noDict) /static/ \|\| (dictMode == ZSTD_dictMatchState) /static/ \|\| (matchIndex3 >= dictLimit)) {
	const BYTE* const match = base + matchIndex3;
	mlen = ZSTD_count(ip, match, iLimit);
	} else {
	const BYTE* const match = dictBase + matchIndex3;
	mlen = ZSTD_count_2segments(ip, match, iLimit, dictEnd, prefixStart);
	}

	/* save best solution */
	if (mlen >= mls /* == 3 > bestLength */) {
	DEBUGLOG(8, "found small match with hlog3, of length %u",
	(U32)mlen);
	bestLength = mlen;
	assert(current > matchIndex3);
	assert(mnum==0); /* no prior solution */
	matches[0].off = (current - matchIndex3) + ZSTD_REP_MOVE;
	matches[0].len = (U32)mlen;
	mnum = 1;
	if ( (mlen > sufficient_len) \|
	(ip+mlen == iLimit) ) { /* best possible length */
	ms->nextToUpdate = current+1; /* skip insertion */
	return 1;
	} } }
	/* no dictMatchState lookup: dicts don't have a populated HC3 table */
	}

	hashTable[h] = current; /* Update Hash Table */

	while (nbCompares-- && (matchIndex >= matchLow)) {
	U32* const nextPtr = bt + 2*(matchIndex & btMask);
	const BYTE* match;
	size_t matchLength = MIN(commonLengthSmaller, commonLengthLarger); /* guaranteed minimum nb of common bytes */
	assert(current > matchIndex);

	if ((dictMode == ZSTD_noDict) \|\| (dictMode == ZSTD_dictMatchState) \|\| (matchIndex+matchLength >= dictLimit)) {
	assert(matchIndex+matchLength >= dictLimit); /* ensure the condition is correct when !extDict */
	match = base + matchIndex;
	if (matchIndex >= dictLimit) assert(memcmp(match, ip, matchLength) == 0); /* ensure early section of match is equal as expected */
	matchLength += ZSTD_count(ip+matchLength, match+matchLength, iLimit);
	} else {
	match = dictBase + matchIndex;
	assert(memcmp(match, ip, matchLength) == 0); /* ensure early section of match is equal as expected */
	matchLength += ZSTD_count_2segments(ip+matchLength, match+matchLength, iLimit, dictEnd, prefixStart);
	if (matchIndex+matchLength >= dictLimit)
	match = base + matchIndex; /* prepare for match[matchLength] read */
	}

	if (matchLength > bestLength) {
	DEBUGLOG(8, "found match of length %u at distance %u (offCode=%u)",
	(U32)matchLength, current - matchIndex, current - matchIndex + ZSTD_REP_MOVE);
	assert(matchEndIdx > matchIndex);
	if (matchLength > matchEndIdx - matchIndex)
	matchEndIdx = matchIndex + (U32)matchLength;
	bestLength = matchLength;
	matches[mnum].off = (current - matchIndex) + ZSTD_REP_MOVE;
	matches[mnum].len = (U32)matchLength;
	mnum++;
	if ( (matchLength > ZSTD_OPT_NUM)
	\| (ip+matchLength == iLimit) /* equal : no way to know if inf or sup */) {
	if (dictMode == ZSTD_dictMatchState) nbCompares = 0; /* break should also skip searching dms */
	break; /* drop, to preserve bt consistency (miss a little bit of compression) */
	}
	}

	if (match[matchLength] < ip[matchLength]) {
	/* match smaller than current */
	smallerPtr = matchIndex; / update smaller idx */
	commonLengthSmaller = matchLength; /* all smaller will now have at least this guaranteed common length */
	if (matchIndex <= btLow) { smallerPtr=&dummy32; break; } /* beyond tree size, stop the search */
	smallerPtr = nextPtr+1; /* new candidate => larger than match, which was smaller than current */
	matchIndex = nextPtr[1]; /* new matchIndex, larger than previous, closer to current */
	} else {
	*largerPtr = matchIndex;
	commonLengthLarger = matchLength;
	if (matchIndex <= btLow) { largerPtr=&dummy32; break; } /* beyond tree size, stop the search */
	largerPtr = nextPtr;
	matchIndex = nextPtr[0];
	} }

	smallerPtr = largerPtr = 0;

	if (dictMode == ZSTD_dictMatchState && nbCompares) {
	size_t const dmsH = ZSTD_hashPtr(ip, dmsHashLog, mls);
	U32 dictMatchIndex = dms->hashTable[dmsH];
	const U32* const dmsBt = dms->chainTable;
	commonLengthSmaller = commonLengthLarger = 0;
	while (nbCompares-- && (dictMatchIndex > dmsLowLimit)) {
	const U32* const nextPtr = dmsBt + 2*(dictMatchIndex & dmsBtMask);
	size_t matchLength = MIN(commonLengthSmaller, commonLengthLarger); /* guaranteed minimum nb of common bytes */
	const BYTE* match = dmsBase + dictMatchIndex;
	matchLength += ZSTD_count_2segments(ip+matchLength, match+matchLength, iLimit, dmsEnd, prefixStart);
	if (dictMatchIndex+matchLength >= dmsHighLimit)
	match = base + dictMatchIndex + dmsIndexDelta; /* to prepare for next usage of match[matchLength] */

	if (matchLength > bestLength) {
	matchIndex = dictMatchIndex + dmsIndexDelta;
	DEBUGLOG(8, "found dms match of length %u at distance %u (offCode=%u)",
	(U32)matchLength, current - matchIndex, current - matchIndex + ZSTD_REP_MOVE);
	if (matchLength > matchEndIdx - matchIndex)
	matchEndIdx = matchIndex + (U32)matchLength;
	bestLength = matchLength;
	matches[mnum].off = (current - matchIndex) + ZSTD_REP_MOVE;
	matches[mnum].len = (U32)matchLength;
	mnum++;
	if ( (matchLength > ZSTD_OPT_NUM)
	\| (ip+matchLength == iLimit) /* equal : no way to know if inf or sup */) {
	break; /* drop, to guarantee consistency (miss a little bit of compression) */
	}
	}

	if (dictMatchIndex <= dmsBtLow) { break; } /* beyond tree size, stop the search */
	if (match[matchLength] < ip[matchLength]) {
	commonLengthSmaller = matchLength; /* all smaller will now have at least this guaranteed common length */
	dictMatchIndex = nextPtr[1]; /* new matchIndex larger than previous (closer to current) */
	} else {
	/* match is larger than current */
	commonLengthLarger = matchLength;
	dictMatchIndex = nextPtr[0];
	}
	}
	}

	assert(matchEndIdx > current+8);
	ms->nextToUpdate = matchEndIdx - 8; /* skip repetitive patterns */
	return mnum;
	}


	FORCE_INLINE_TEMPLATE U32 ZSTD_BtGetAllMatches (
	ZSTD_match_t* matches, /* store result (match found, increasing size) in this table */
	ZSTD_matchState_t* ms,
	U32* nextToUpdate3,
	const BYTE* ip, const BYTE* const iHighLimit, const ZSTD_dictMode_e dictMode,
	const U32 rep[ZSTD_REP_NUM],
	U32 const ll0,
	U32 const lengthToBeat)
	{
	const ZSTD_compressionParameters* const cParams = &ms->cParams;
	U32 const matchLengthSearch = cParams->minMatch;
	DEBUGLOG(8, "ZSTD_BtGetAllMatches");
	if (ip < ms->window.base + ms->nextToUpdate) return 0; /* skipped area */
	ZSTD_updateTree_internal(ms, ip, iHighLimit, matchLengthSearch, dictMode);
	switch(matchLengthSearch)
	{
	case 3 : return ZSTD_insertBtAndGetAllMatches(matches, ms, nextToUpdate3, ip, iHighLimit, dictMode, rep, ll0, lengthToBeat, 3);
	default :
	case 4 : return ZSTD_insertBtAndGetAllMatches(matches, ms, nextToUpdate3, ip, iHighLimit, dictMode, rep, ll0, lengthToBeat, 4);
	case 5 : return ZSTD_insertBtAndGetAllMatches(matches, ms, nextToUpdate3, ip, iHighLimit, dictMode, rep, ll0, lengthToBeat, 5);
	case 7 :
	case 6 : return ZSTD_insertBtAndGetAllMatches(matches, ms, nextToUpdate3, ip, iHighLimit, dictMode, rep, ll0, lengthToBeat, 6);
	}
	}


	/-******************************
	* Optimal parser
	*********************************/


	static U32 ZSTD_totalLen(ZSTD_optimal_t sol)
	{
	return sol.litlen + sol.mlen;
	}

	#if 0 /* debug */

	static void
	listStats(const U32* table, int lastEltID)
	{
	int const nbElts = lastEltID + 1;
	int enb;
	for (enb=0; enb < nbElts; enb++) {
	(void)table;
	/* RAWLOG(2, "%3i:%3i, ", enb, table[enb]); */
	RAWLOG(2, "%4i,", table[enb]);
	}
	RAWLOG(2, " \n");
	}

	#endif

	FORCE_INLINE_TEMPLATE size_t
	ZSTD_compressBlock_opt_generic(ZSTD_matchState_t* ms,
	seqStore_t* seqStore,
	U32 rep[ZSTD_REP_NUM],
	const void* src, size_t srcSize,
	const int optLevel,
	const ZSTD_dictMode_e dictMode)
	{
	optState_t* const optStatePtr = &ms->opt;
	const BYTE* const istart = (const BYTE*)src;
	const BYTE* ip = istart;
	const BYTE* anchor = istart;
	const BYTE* const iend = istart + srcSize;
	const BYTE* const ilimit = iend - 8;
	const BYTE* const base = ms->window.base;
	const BYTE* const prefixStart = base + ms->window.dictLimit;
	const ZSTD_compressionParameters* const cParams = &ms->cParams;

	U32 const sufficient_len = MIN(cParams->targetLength, ZSTD_OPT_NUM -1);
	U32 const minMatch = (cParams->minMatch == 3) ? 3 : 4;
	U32 nextToUpdate3 = ms->nextToUpdate;

	ZSTD_optimal_t* const opt = optStatePtr->priceTable;
	ZSTD_match_t* const matches = optStatePtr->matchTable;
	ZSTD_optimal_t lastSequence;

	/* init */
	DEBUGLOG(5, "ZSTD_compressBlock_opt_generic: current=%u, prefix=%u, nextToUpdate=%u",
	(U32)(ip - base), ms->window.dictLimit, ms->nextToUpdate);
	assert(optLevel <= 2);
	ZSTD_rescaleFreqs(optStatePtr, (const BYTE*)src, srcSize, optLevel);
	ip += (ip==prefixStart);

	/* Match Loop */
	while (ip < ilimit) {
	U32 cur, last_pos = 0;

	/* find first match */
	{ U32 const litlen = (U32)(ip - anchor);
	U32 const ll0 = !litlen;
	U32 const nbMatches = ZSTD_BtGetAllMatches(matches, ms, &nextToUpdate3, ip, iend, dictMode, rep, ll0, minMatch);
	if (!nbMatches) { ip++; continue; }

	/* initialize opt[0] */
	{ U32 i ; for (i=0; i<ZSTD_REP_NUM; i++) opt[0].rep[i] = rep[i]; }
	opt[0].mlen = 0; /* means is_a_literal */
	opt[0].litlen = litlen;
	/* We don't need to include the actual price of the literals because
	* it is static for the duration of the forward pass, and is included
	* in every price. We include the literal length to avoid negative
	* prices when we subtract the previous literal length.
	*/
	opt[0].price = ZSTD_litLengthPrice(litlen, optStatePtr, optLevel);

	/* large match -> immediate encoding */
	{ U32 const maxML = matches[nbMatches-1].len;
	U32 const maxOffset = matches[nbMatches-1].off;
	DEBUGLOG(6, "found %u matches of maxLength=%u and maxOffCode=%u at cPos=%u => start new series",
	nbMatches, maxML, maxOffset, (U32)(ip-prefixStart));

	if (maxML > sufficient_len) {
	lastSequence.litlen = litlen;
	lastSequence.mlen = maxML;
	lastSequence.off = maxOffset;
	DEBUGLOG(6, "large match (%u>%u), immediate encoding",
	maxML, sufficient_len);
	cur = 0;
	last_pos = ZSTD_totalLen(lastSequence);
	goto _shortestPath;
	} }

	/* set prices for first matches starting position == 0 */
	{ U32 const literalsPrice = opt[0].price + ZSTD_litLengthPrice(0, optStatePtr, optLevel);
	U32 pos;
	U32 matchNb;
	for (pos = 1; pos < minMatch; pos++) {
	opt[pos].price = ZSTD_MAX_PRICE; /* mlen, litlen and price will be fixed during forward scanning */
	}
	for (matchNb = 0; matchNb < nbMatches; matchNb++) {
	U32 const offset = matches[matchNb].off;
	U32 const end = matches[matchNb].len;
	for ( ; pos <= end ; pos++ ) {
	U32 const matchPrice = ZSTD_getMatchPrice(offset, pos, optStatePtr, optLevel);
	U32 const sequencePrice = literalsPrice + matchPrice;
	DEBUGLOG(7, "rPos:%u => set initial price : %.2f",
	pos, ZSTD_fCost(sequencePrice));
	opt[pos].mlen = pos;
	opt[pos].off = offset;
	opt[pos].litlen = litlen;
	opt[pos].price = sequencePrice;
	} }
	last_pos = pos-1;
	}
	}

	/* check further positions */
	for (cur = 1; cur <= last_pos; cur++) {
	const BYTE* const inr = ip + cur;
	assert(cur < ZSTD_OPT_NUM);
	DEBUGLOG(7, "cPos:%zi==rPos:%u", inr-istart, cur)

	/* Fix current position with one literal if cheaper */
	{ U32 const litlen = (opt[cur-1].mlen == 0) ? opt[cur-1].litlen + 1 : 1;
	int const price = opt[cur-1].price
	+ ZSTD_rawLiteralsCost(ip+cur-1, 1, optStatePtr, optLevel)
	+ ZSTD_litLengthPrice(litlen, optStatePtr, optLevel)
	- ZSTD_litLengthPrice(litlen-1, optStatePtr, optLevel);
	assert(price < 1000000000); /* overflow check */
	if (price <= opt[cur].price) {
	DEBUGLOG(7, "cPos:%zi==rPos:%u : better price (%.2f<=%.2f) using literal (ll==%u) (hist:%u,%u,%u)",
	inr-istart, cur, ZSTD_fCost(price), ZSTD_fCost(opt[cur].price), litlen,
	opt[cur-1].rep[0], opt[cur-1].rep[1], opt[cur-1].rep[2]);
	opt[cur].mlen = 0;
	opt[cur].off = 0;
	opt[cur].litlen = litlen;
	opt[cur].price = price;
	} else {
	DEBUGLOG(7, "cPos:%zi==rPos:%u : literal would cost more (%.2f>%.2f) (hist:%u,%u,%u)",
	inr-istart, cur, ZSTD_fCost(price), ZSTD_fCost(opt[cur].price),
	opt[cur].rep[0], opt[cur].rep[1], opt[cur].rep[2]);
	}
	}

	/* Set the repcodes of the current position. We must do it here
	* because we rely on the repcodes of the 2nd to last sequence being
	* correct to set the next chunks repcodes during the backward
	* traversal.
	*/
	ZSTD_STATIC_ASSERT(sizeof(opt[cur].rep) == sizeof(repcodes_t));
	assert(cur >= opt[cur].mlen);
	if (opt[cur].mlen != 0) {
	U32 const prev = cur - opt[cur].mlen;
	repcodes_t newReps = ZSTD_updateRep(opt[prev].rep, opt[cur].off, opt[cur].litlen==0);
	memcpy(opt[cur].rep, &newReps, sizeof(repcodes_t));
	} else {
	memcpy(opt[cur].rep, opt[cur - 1].rep, sizeof(repcodes_t));
	}

	/* last match must start at a minimum distance of 8 from oend */
	if (inr > ilimit) continue;

	if (cur == last_pos) break;

	if ( (optLevel==0) /static_test/
	&& (opt[cur+1].price <= opt[cur].price + (BITCOST_MULTIPLIER/2)) ) {
	DEBUGLOG(7, "move to next rPos:%u : price is <=", cur+1);
	continue; /* skip unpromising positions; about ~+6% speed, -0.01 ratio */
	}

	{ U32 const ll0 = (opt[cur].mlen != 0);
	U32 const litlen = (opt[cur].mlen == 0) ? opt[cur].litlen : 0;
	U32 const previousPrice = opt[cur].price;
	U32 const basePrice = previousPrice + ZSTD_litLengthPrice(0, optStatePtr, optLevel);
	U32 const nbMatches = ZSTD_BtGetAllMatches(matches, ms, &nextToUpdate3, inr, iend, dictMode, opt[cur].rep, ll0, minMatch);
	U32 matchNb;
	if (!nbMatches) {
	DEBUGLOG(7, "rPos:%u : no match found", cur);
	continue;
	}

	{ U32 const maxML = matches[nbMatches-1].len;
	DEBUGLOG(7, "cPos:%zi==rPos:%u, found %u matches, of maxLength=%u",
	inr-istart, cur, nbMatches, maxML);

	if ( (maxML > sufficient_len)
	\|\| (cur + maxML >= ZSTD_OPT_NUM) ) {
	lastSequence.mlen = maxML;
	lastSequence.off = matches[nbMatches-1].off;
	lastSequence.litlen = litlen;
	cur -= (opt[cur].mlen==0) ? opt[cur].litlen : 0; /* last sequence is actually only literals, fix cur to last match - note : may underflow, in which case, it's first sequence, and it's okay */
	last_pos = cur + ZSTD_totalLen(lastSequence);
	if (cur > ZSTD_OPT_NUM) cur = 0; /* underflow => first match */
	goto _shortestPath;
	} }

	/* set prices using matches found at position == cur */
	for (matchNb = 0; matchNb < nbMatches; matchNb++) {
	U32 const offset = matches[matchNb].off;
	U32 const lastML = matches[matchNb].len;
	U32 const startML = (matchNb>0) ? matches[matchNb-1].len+1 : minMatch;
	U32 mlen;

	DEBUGLOG(7, "testing match %u => offCode=%4u, mlen=%2u, llen=%2u",
	matchNb, matches[matchNb].off, lastML, litlen);

	for (mlen = lastML; mlen >= startML; mlen--) { /* scan downward */
	U32 const pos = cur + mlen;
	int const price = basePrice + ZSTD_getMatchPrice(offset, mlen, optStatePtr, optLevel);

	if ((pos > last_pos) \|\| (price < opt[pos].price)) {
	DEBUGLOG(7, "rPos:%u (ml=%2u) => new better price (%.2f<%.2f)",
	pos, mlen, ZSTD_fCost(price), ZSTD_fCost(opt[pos].price));
	while (last_pos < pos) { opt[last_pos+1].price = ZSTD_MAX_PRICE; last_pos++; } /* fill empty positions */
	opt[pos].mlen = mlen;
	opt[pos].off = offset;
	opt[pos].litlen = litlen;
	opt[pos].price = price;
	} else {
	DEBUGLOG(7, "rPos:%u (ml=%2u) => new price is worse (%.2f>=%.2f)",
	pos, mlen, ZSTD_fCost(price), ZSTD_fCost(opt[pos].price));
	if (optLevel==0) break; /* early update abort; gets ~+10% speed for about -0.01 ratio loss */
	}
	} } }
	} /* for (cur = 1; cur <= last_pos; cur++) */

	lastSequence = opt[last_pos];
	cur = last_pos > ZSTD_totalLen(lastSequence) ? last_pos - ZSTD_totalLen(lastSequence) : 0; /* single sequence, and it starts before `ip` */
	assert(cur < ZSTD_OPT_NUM); /* control overflow*/

	_shortestPath: /* cur, last_pos, best_mlen, best_off have to be set */
	assert(opt[0].mlen == 0);

	/* Set the next chunk's repcodes based on the repcodes of the beginning
	* of the last match, and the last sequence. This avoids us having to
	* update them while traversing the sequences.
	*/
	if (lastSequence.mlen != 0) {
	repcodes_t reps = ZSTD_updateRep(opt[cur].rep, lastSequence.off, lastSequence.litlen==0);
	memcpy(rep, &reps, sizeof(reps));
	} else {
	memcpy(rep, opt[cur].rep, sizeof(repcodes_t));
	}

	{ U32 const storeEnd = cur + 1;
	U32 storeStart = storeEnd;
	U32 seqPos = cur;

	DEBUGLOG(6, "start reverse traversal (last_pos:%u, cur:%u)",
	last_pos, cur); (void)last_pos;
	assert(storeEnd < ZSTD_OPT_NUM);
	DEBUGLOG(6, "last sequence copied into pos=%u (llen=%u,mlen=%u,ofc=%u)",
	storeEnd, lastSequence.litlen, lastSequence.mlen, lastSequence.off);
	opt[storeEnd] = lastSequence;
	while (seqPos > 0) {
	U32 const backDist = ZSTD_totalLen(opt[seqPos]);
	storeStart--;
	DEBUGLOG(6, "sequence from rPos=%u copied into pos=%u (llen=%u,mlen=%u,ofc=%u)",
	seqPos, storeStart, opt[seqPos].litlen, opt[seqPos].mlen, opt[seqPos].off);
	opt[storeStart] = opt[seqPos];
	seqPos = (seqPos > backDist) ? seqPos - backDist : 0;
	}

	/* save sequences */
	DEBUGLOG(6, "sending selected sequences into seqStore")
	{ U32 storePos;
	for (storePos=storeStart; storePos <= storeEnd; storePos++) {
	U32 const llen = opt[storePos].litlen;
	U32 const mlen = opt[storePos].mlen;
	U32 const offCode = opt[storePos].off;
	U32 const advance = llen + mlen;
	DEBUGLOG(6, "considering seq starting at %zi, llen=%u, mlen=%u",
	anchor - istart, (unsigned)llen, (unsigned)mlen);

	if (mlen==0) { /* only literals => must be last "sequence", actually starting a new stream of sequences */
	assert(storePos == storeEnd); /* must be last sequence */
	ip = anchor + llen; /* last "sequence" is a bunch of literals => don't progress anchor */
	continue; /* will finish */
	}

	assert(anchor + llen <= iend);
	ZSTD_updateStats(optStatePtr, llen, anchor, offCode, mlen);
	ZSTD_storeSeq(seqStore, llen, anchor, iend, offCode, mlen-MINMATCH);
	anchor += advance;
	ip = anchor;
	} }
	ZSTD_setBasePrices(optStatePtr, optLevel);
	}
	} /* while (ip < ilimit) */

	/* Return the last literals size */
	return (size_t)(iend - anchor);
	}


	size_t ZSTD_compressBlock_btopt(
	ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
	const void* src, size_t srcSize)
	{
	DEBUGLOG(5, "ZSTD_compressBlock_btopt");
	return ZSTD_compressBlock_opt_generic(ms, seqStore, rep, src, srcSize, 0 /optLevel/, ZSTD_noDict);
	}


	/* used in 2-pass strategy */
	static U32 ZSTD_upscaleStat(unsigned* table, U32 lastEltIndex, int bonus)
	{
	U32 s, sum=0;
	assert(ZSTD_FREQ_DIV+bonus >= 0);
	for (s=0; s<lastEltIndex+1; s++) {
	table[s] <<= ZSTD_FREQ_DIV+bonus;
	table[s]--;
	sum += table[s];
	}
	return sum;
	}

	/* used in 2-pass strategy */
	MEM_STATIC void ZSTD_upscaleStats(optState_t* optPtr)
	{
	if (ZSTD_compressedLiterals(optPtr))
	optPtr->litSum = ZSTD_upscaleStat(optPtr->litFreq, MaxLit, 0);
	optPtr->litLengthSum = ZSTD_upscaleStat(optPtr->litLengthFreq, MaxLL, 0);
	optPtr->matchLengthSum = ZSTD_upscaleStat(optPtr->matchLengthFreq, MaxML, 0);
	optPtr->offCodeSum = ZSTD_upscaleStat(optPtr->offCodeFreq, MaxOff, 0);
	}

	/* ZSTD_initStats_ultra():
	* make a first compression pass, just to seed stats with more accurate starting values.
	* only works on first block, with no dictionary and no ldm.
	* this function cannot error, hence its contract must be respected.
	*/
	static void
	ZSTD_initStats_ultra(ZSTD_matchState_t* ms,
	seqStore_t* seqStore,
	U32 rep[ZSTD_REP_NUM],
	const void* src, size_t srcSize)
	{
	U32 tmpRep[ZSTD_REP_NUM]; /* updated rep codes will sink here */
	memcpy(tmpRep, rep, sizeof(tmpRep));

	DEBUGLOG(4, "ZSTD_initStats_ultra (srcSize=%zu)", srcSize);
	assert(ms->opt.litLengthSum == 0); /* first block */
	assert(seqStore->sequences == seqStore->sequencesStart); /* no ldm */
	assert(ms->window.dictLimit == ms->window.lowLimit); /* no dictionary */
	assert(ms->window.dictLimit - ms->nextToUpdate <= 1); /* no prefix (note: intentional overflow, defined as 2-complement) */

	ZSTD_compressBlock_opt_generic(ms, seqStore, tmpRep, src, srcSize, 2 /optLevel/, ZSTD_noDict); /* generate stats into ms->opt*/

	/* invalidate first scan from history */
	ZSTD_resetSeqStore(seqStore);
	ms->window.base -= srcSize;
	ms->window.dictLimit += (U32)srcSize;
	ms->window.lowLimit = ms->window.dictLimit;
	ms->nextToUpdate = ms->window.dictLimit;

	/* re-inforce weight of collected statistics */
	ZSTD_upscaleStats(&ms->opt);
	}

	size_t ZSTD_compressBlock_btultra(
	ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
	const void* src, size_t srcSize)
	{
	DEBUGLOG(5, "ZSTD_compressBlock_btultra (srcSize=%zu)", srcSize);
	return ZSTD_compressBlock_opt_generic(ms, seqStore, rep, src, srcSize, 2 /optLevel/, ZSTD_noDict);
	}

	size_t ZSTD_compressBlock_btultra2(
	ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
	const void* src, size_t srcSize)
	{
	U32 const current = (U32)((const BYTE*)src - ms->window.base);
	DEBUGLOG(5, "ZSTD_compressBlock_btultra2 (srcSize=%zu)", srcSize);

	/* 2-pass strategy:
	* this strategy makes a first pass over first block to collect statistics
	* and seed next round's statistics with it.
	* After 1st pass, function forgets everything, and starts a new block.
	* Consequently, this can only work if no data has been previously loaded in tables,
	* aka, no dictionary, no prefix, no ldm preprocessing.
	* The compression ratio gain is generally small (~0.5% on first block),
	* the cost is 2x cpu time on first block. */
	assert(srcSize <= ZSTD_BLOCKSIZE_MAX);
	if ( (ms->opt.litLengthSum==0) /* first block */
	&& (seqStore->sequences == seqStore->sequencesStart) /* no ldm */
	&& (ms->window.dictLimit == ms->window.lowLimit) /* no dictionary */
	&& (current == ms->window.dictLimit) /* start of frame, nothing already loaded nor skipped */
	&& (srcSize > ZSTD_PREDEF_THRESHOLD)
	) {
	ZSTD_initStats_ultra(ms, seqStore, rep, src, srcSize);
	}

	return ZSTD_compressBlock_opt_generic(ms, seqStore, rep, src, srcSize, 2 /optLevel/, ZSTD_noDict);
	}

	size_t ZSTD_compressBlock_btopt_dictMatchState(
	ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
	const void* src, size_t srcSize)
	{
	return ZSTD_compressBlock_opt_generic(ms, seqStore, rep, src, srcSize, 0 /optLevel/, ZSTD_dictMatchState);
	}

	size_t ZSTD_compressBlock_btultra_dictMatchState(
	ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
	const void* src, size_t srcSize)
	{
	return ZSTD_compressBlock_opt_generic(ms, seqStore, rep, src, srcSize, 2 /optLevel/, ZSTD_dictMatchState);
	}

	size_t ZSTD_compressBlock_btopt_extDict(
	ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
	const void* src, size_t srcSize)
	{
	return ZSTD_compressBlock_opt_generic(ms, seqStore, rep, src, srcSize, 0 /optLevel/, ZSTD_extDict);
	}

	size_t ZSTD_compressBlock_btultra_extDict(
	ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
	const void* src, size_t srcSize)
	{
	return ZSTD_compressBlock_opt_generic(ms, seqStore, rep, src, srcSize, 2 /optLevel/, ZSTD_extDict);
	}

	/* note : no btultra2 variant for extDict nor dictMatchState,
	* because btultra2 is not meant to work with dictionaries
	* and is only specific for the first block (no prefix) */
	/** ended inlining compress/zstd_opt.c **/

	/** start inlining decompress/huf_decompress.c **/
	/* ******************************************************************
	* huff0 huffman decoder,
	* part of Finite State Entropy library
	* Copyright (c) 2013-2020, Yann Collet, Facebook, Inc.
	*
	* You can contact the author at :
	* - FSE+HUF source repository : https://github.com/Cyan4973/FiniteStateEntropy
	*
	* This source code is licensed under both the BSD-style license (found in the
	* LICENSE file in the root directory of this source tree) and the GPLv2 (found
	* in the COPYING file in the root directory of this source tree).
	* You may select, at your option, one of the above-listed licenses.
	****************************************************************** */

	/* **************************************************************
	* Dependencies
	****************************************************************/
	#include <string.h> /* memcpy, memset */
	/** skipping file: ../common/compiler.h **/
	/** skipping file: ../common/bitstream.h **/
	/** skipping file: ../common/fse.h **/
	#define HUF_STATIC_LINKING_ONLY
	/** skipping file: ../common/huf.h **/
	/** skipping file: ../common/error_private.h **/

	/* **************************************************************
	* Macros
	****************************************************************/

	/* These two optional macros force the use one way or another of the two
	* Huffman decompression implementations. You can't force in both directions
	* at the same time.
	*/
	#if defined(HUF_FORCE_DECOMPRESS_X1) && \
	defined(HUF_FORCE_DECOMPRESS_X2)
	#error "Cannot force the use of the X1 and X2 decoders at the same time!"
	#endif


	/* **************************************************************
	* Error Management
	****************************************************************/
	#define HUF_isError ERR_isError


	/* **************************************************************
	* Byte alignment for workSpace management
	****************************************************************/
	#define HUF_ALIGN(x, a) HUF_ALIGN_MASK((x), (a) - 1)
	#define HUF_ALIGN_MASK(x, mask) (((x) + (mask)) & ~(mask))


	/* **************************************************************
	* BMI2 Variant Wrappers
	****************************************************************/
	#if DYNAMIC_BMI2

	#define HUF_DGEN(fn) \
	\
	static size_t fn##_default( \
	void* dst, size_t dstSize, \
	const void* cSrc, size_t cSrcSize, \
	const HUF_DTable* DTable) \
	{ \
	return fn##_body(dst, dstSize, cSrc, cSrcSize, DTable); \
	} \
	\
	static TARGET_ATTRIBUTE("bmi2") size_t fn##_bmi2( \
	void* dst, size_t dstSize, \
	const void* cSrc, size_t cSrcSize, \
	const HUF_DTable* DTable) \
	{ \
	return fn##_body(dst, dstSize, cSrc, cSrcSize, DTable); \
	} \
	\
	static size_t fn(void* dst, size_t dstSize, void const* cSrc, \
	size_t cSrcSize, HUF_DTable const* DTable, int bmi2) \
	{ \
	if (bmi2) { \
	return fn##_bmi2(dst, dstSize, cSrc, cSrcSize, DTable); \
	} \
	return fn##_default(dst, dstSize, cSrc, cSrcSize, DTable); \
	}

	#else

	#define HUF_DGEN(fn) \
	static size_t fn(void* dst, size_t dstSize, void const* cSrc, \
	size_t cSrcSize, HUF_DTable const* DTable, int bmi2) \
	{ \
	(void)bmi2; \
	return fn##_body(dst, dstSize, cSrc, cSrcSize, DTable); \
	}

	#endif


	/-**************************/
	/* generic DTableDesc */
	/-**************************/
	typedef struct { BYTE maxTableLog; BYTE tableType; BYTE tableLog; BYTE reserved; } DTableDesc;

	static DTableDesc HUF_getDTableDesc(const HUF_DTable* table)
	{
	DTableDesc dtd;
	memcpy(&dtd, table, sizeof(dtd));
	return dtd;
	}


	#ifndef HUF_FORCE_DECOMPRESS_X2

	/-**************************/
	/* single-symbol decoding */
	/-**************************/
	typedef struct { BYTE byte; BYTE nbBits; } HUF_DEltX1; /* single-symbol decoding */

	size_t HUF_readDTableX1_wksp(HUF_DTable* DTable, const void* src, size_t srcSize, void* workSpace, size_t wkspSize)
	{
	U32 tableLog = 0;
	U32 nbSymbols = 0;
	size_t iSize;
	void* const dtPtr = DTable + 1;
	HUF_DEltX1* const dt = (HUF_DEltX1*)dtPtr;

	U32* rankVal;
	BYTE* huffWeight;
	size_t spaceUsed32 = 0;

	rankVal = (U32 *)workSpace + spaceUsed32;
	spaceUsed32 += HUF_TABLELOG_ABSOLUTEMAX + 1;
	huffWeight = (BYTE )((U32 )workSpace + spaceUsed32);
	spaceUsed32 += HUF_ALIGN(HUF_SYMBOLVALUE_MAX + 1, sizeof(U32)) >> 2;

	if ((spaceUsed32 << 2) > wkspSize) return ERROR(tableLog_tooLarge);

	DEBUG_STATIC_ASSERT(sizeof(DTableDesc) == sizeof(HUF_DTable));
	/* memset(huffWeight, 0, sizeof(huffWeight)); / / is not necessary, even though some analyzer complain ... */

	iSize = HUF_readStats(huffWeight, HUF_SYMBOLVALUE_MAX + 1, rankVal, &nbSymbols, &tableLog, src, srcSize);
	if (HUF_isError(iSize)) return iSize;

	/* Table header */
	{ DTableDesc dtd = HUF_getDTableDesc(DTable);
	if (tableLog > (U32)(dtd.maxTableLog+1)) return ERROR(tableLog_tooLarge); /* DTable too small, Huffman tree cannot fit in */
	dtd.tableType = 0;
	dtd.tableLog = (BYTE)tableLog;
	memcpy(DTable, &dtd, sizeof(dtd));
	}

	/* Calculate starting value for each rank */
	{ U32 n, nextRankStart = 0;
	for (n=1; n<tableLog+1; n++) {
	U32 const current = nextRankStart;
	nextRankStart += (rankVal[n] << (n-1));
	rankVal[n] = current;
	} }

	/* fill DTable */
	{ U32 n;
	size_t const nEnd = nbSymbols;
	for (n=0; n<nEnd; n++) {
	size_t const w = huffWeight[n];
	size_t const length = (1 << w) >> 1;
	size_t const uStart = rankVal[w];
	size_t const uEnd = uStart + length;
	size_t u;
	HUF_DEltX1 D;
	D.byte = (BYTE)n;
	D.nbBits = (BYTE)(tableLog + 1 - w);
	rankVal[w] = (U32)uEnd;
	if (length < 4) {
	/* Use length in the loop bound so the compiler knows it is short. */
	for (u = 0; u < length; ++u)
	dt[uStart + u] = D;
	} else {
	/* Unroll the loop 4 times, we know it is a power of 2. */
	for (u = uStart; u < uEnd; u += 4) {
	dt[u + 0] = D;
	dt[u + 1] = D;
	dt[u + 2] = D;
	dt[u + 3] = D;
	} } } }
	return iSize;
	}

	size_t HUF_readDTableX1(HUF_DTable* DTable, const void* src, size_t srcSize)
	{
	U32 workSpace[HUF_DECOMPRESS_WORKSPACE_SIZE_U32];
	return HUF_readDTableX1_wksp(DTable, src, srcSize,
	workSpace, sizeof(workSpace));
	}

	FORCE_INLINE_TEMPLATE BYTE
	HUF_decodeSymbolX1(BIT_DStream_t* Dstream, const HUF_DEltX1* dt, const U32 dtLog)
	{
	size_t const val = BIT_lookBitsFast(Dstream, dtLog); /* note : dtLog >= 1 */
	BYTE const c = dt[val].byte;
	BIT_skipBits(Dstream, dt[val].nbBits);
	return c;
	}

	#define HUF_DECODE_SYMBOLX1_0(ptr, DStreamPtr) \
	*ptr++ = HUF_decodeSymbolX1(DStreamPtr, dt, dtLog)

	#define HUF_DECODE_SYMBOLX1_1(ptr, DStreamPtr) \
	if (MEM_64bits() \|\| (HUF_TABLELOG_MAX<=12)) \
	HUF_DECODE_SYMBOLX1_0(ptr, DStreamPtr)

	#define HUF_DECODE_SYMBOLX1_2(ptr, DStreamPtr) \
	if (MEM_64bits()) \
	HUF_DECODE_SYMBOLX1_0(ptr, DStreamPtr)

	HINT_INLINE size_t
	HUF_decodeStreamX1(BYTE* p, BIT_DStream_t* const bitDPtr, BYTE* const pEnd, const HUF_DEltX1* const dt, const U32 dtLog)
	{
	BYTE* const pStart = p;

	/* up to 4 symbols at a time */
	while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) & (p < pEnd-3)) {
	HUF_DECODE_SYMBOLX1_2(p, bitDPtr);
	HUF_DECODE_SYMBOLX1_1(p, bitDPtr);
	HUF_DECODE_SYMBOLX1_2(p, bitDPtr);
	HUF_DECODE_SYMBOLX1_0(p, bitDPtr);
	}

	/* [0-3] symbols remaining */
	if (MEM_32bits())
	while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) & (p < pEnd))
	HUF_DECODE_SYMBOLX1_0(p, bitDPtr);

	/* no more data to retrieve from bitstream, no need to reload */
	while (p < pEnd)
	HUF_DECODE_SYMBOLX1_0(p, bitDPtr);

	return pEnd-pStart;
	}

	FORCE_INLINE_TEMPLATE size_t
	HUF_decompress1X1_usingDTable_internal_body(
	void* dst, size_t dstSize,
	const void* cSrc, size_t cSrcSize,
	const HUF_DTable* DTable)
	{
	BYTE* op = (BYTE*)dst;
	BYTE* const oend = op + dstSize;
	const void* dtPtr = DTable + 1;
	const HUF_DEltX1* const dt = (const HUF_DEltX1*)dtPtr;
	BIT_DStream_t bitD;
	DTableDesc const dtd = HUF_getDTableDesc(DTable);
	U32 const dtLog = dtd.tableLog;

	CHECK_F( BIT_initDStream(&bitD, cSrc, cSrcSize) );

	HUF_decodeStreamX1(op, &bitD, oend, dt, dtLog);

	if (!BIT_endOfDStream(&bitD)) return ERROR(corruption_detected);

	return dstSize;
	}

	FORCE_INLINE_TEMPLATE size_t
	HUF_decompress4X1_usingDTable_internal_body(
	void* dst, size_t dstSize,
	const void* cSrc, size_t cSrcSize,
	const HUF_DTable* DTable)
	{
	/* Check */
	if (cSrcSize < 10) return ERROR(corruption_detected); /* strict minimum : jump table + 1 byte per stream */

	{ const BYTE* const istart = (const BYTE*) cSrc;
	BYTE* const ostart = (BYTE*) dst;
	BYTE* const oend = ostart + dstSize;
	BYTE* const olimit = oend - 3;
	const void* const dtPtr = DTable + 1;
	const HUF_DEltX1* const dt = (const HUF_DEltX1*)dtPtr;

	/* Init */
	BIT_DStream_t bitD1;
	BIT_DStream_t bitD2;
	BIT_DStream_t bitD3;
	BIT_DStream_t bitD4;
	size_t const length1 = MEM_readLE16(istart);
	size_t const length2 = MEM_readLE16(istart+2);
	size_t const length3 = MEM_readLE16(istart+4);
	size_t const length4 = cSrcSize - (length1 + length2 + length3 + 6);
	const BYTE* const istart1 = istart + 6; /* jumpTable */
	const BYTE* const istart2 = istart1 + length1;
	const BYTE* const istart3 = istart2 + length2;
	const BYTE* const istart4 = istart3 + length3;
	const size_t segmentSize = (dstSize+3) / 4;
	BYTE* const opStart2 = ostart + segmentSize;
	BYTE* const opStart3 = opStart2 + segmentSize;
	BYTE* const opStart4 = opStart3 + segmentSize;
	BYTE* op1 = ostart;
	BYTE* op2 = opStart2;
	BYTE* op3 = opStart3;
	BYTE* op4 = opStart4;
	DTableDesc const dtd = HUF_getDTableDesc(DTable);
	U32 const dtLog = dtd.tableLog;
	U32 endSignal = 1;

	if (length4 > cSrcSize) return ERROR(corruption_detected); /* overflow */
	CHECK_F( BIT_initDStream(&bitD1, istart1, length1) );
	CHECK_F( BIT_initDStream(&bitD2, istart2, length2) );
	CHECK_F( BIT_initDStream(&bitD3, istart3, length3) );
	CHECK_F( BIT_initDStream(&bitD4, istart4, length4) );

	/* up to 16 symbols per loop (4 symbols per stream) in 64-bit mode */
	for ( ; (endSignal) & (op4 < olimit) ; ) {
	HUF_DECODE_SYMBOLX1_2(op1, &bitD1);
	HUF_DECODE_SYMBOLX1_2(op2, &bitD2);
	HUF_DECODE_SYMBOLX1_2(op3, &bitD3);
	HUF_DECODE_SYMBOLX1_2(op4, &bitD4);
	HUF_DECODE_SYMBOLX1_1(op1, &bitD1);
	HUF_DECODE_SYMBOLX1_1(op2, &bitD2);
	HUF_DECODE_SYMBOLX1_1(op3, &bitD3);
	HUF_DECODE_SYMBOLX1_1(op4, &bitD4);
	HUF_DECODE_SYMBOLX1_2(op1, &bitD1);
	HUF_DECODE_SYMBOLX1_2(op2, &bitD2);
	HUF_DECODE_SYMBOLX1_2(op3, &bitD3);
	HUF_DECODE_SYMBOLX1_2(op4, &bitD4);
	HUF_DECODE_SYMBOLX1_0(op1, &bitD1);
	HUF_DECODE_SYMBOLX1_0(op2, &bitD2);
	HUF_DECODE_SYMBOLX1_0(op3, &bitD3);
	HUF_DECODE_SYMBOLX1_0(op4, &bitD4);
	endSignal &= BIT_reloadDStreamFast(&bitD1) == BIT_DStream_unfinished;
	endSignal &= BIT_reloadDStreamFast(&bitD2) == BIT_DStream_unfinished;
	endSignal &= BIT_reloadDStreamFast(&bitD3) == BIT_DStream_unfinished;
	endSignal &= BIT_reloadDStreamFast(&bitD4) == BIT_DStream_unfinished;
	}

	/* check corruption */
	/* note : should not be necessary : op# advance in lock step, and we control op4.
	* but curiously, binary generated by gcc 7.2 & 7.3 with -mbmi2 runs faster when >=1 test is present */
	if (op1 > opStart2) return ERROR(corruption_detected);
	if (op2 > opStart3) return ERROR(corruption_detected);
	if (op3 > opStart4) return ERROR(corruption_detected);
	/* note : op4 supposed already verified within main loop */

	/* finish bitStreams one by one */
	HUF_decodeStreamX1(op1, &bitD1, opStart2, dt, dtLog);
	HUF_decodeStreamX1(op2, &bitD2, opStart3, dt, dtLog);
	HUF_decodeStreamX1(op3, &bitD3, opStart4, dt, dtLog);
	HUF_decodeStreamX1(op4, &bitD4, oend, dt, dtLog);

	/* check */
	{ U32 const endCheck = BIT_endOfDStream(&bitD1) & BIT_endOfDStream(&bitD2) & BIT_endOfDStream(&bitD3) & BIT_endOfDStream(&bitD4);
	if (!endCheck) return ERROR(corruption_detected); }

	/* decoded size */
	return dstSize;
	}
	}


	typedef size_t (HUF_decompress_usingDTable_t)(void dst, size_t dstSize,
	const void *cSrc,
	size_t cSrcSize,
	const HUF_DTable *DTable);

	HUF_DGEN(HUF_decompress1X1_usingDTable_internal)
	HUF_DGEN(HUF_decompress4X1_usingDTable_internal)



	size_t HUF_decompress1X1_usingDTable(
	void* dst, size_t dstSize,
	const void* cSrc, size_t cSrcSize,
	const HUF_DTable* DTable)
	{
	DTableDesc dtd = HUF_getDTableDesc(DTable);
	if (dtd.tableType != 0) return ERROR(GENERIC);
	return HUF_decompress1X1_usingDTable_internal(dst, dstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0);
	}

	size_t HUF_decompress1X1_DCtx_wksp(HUF_DTable* DCtx, void* dst, size_t dstSize,
	const void* cSrc, size_t cSrcSize,
	void* workSpace, size_t wkspSize)
	{
	const BYTE* ip = (const BYTE*) cSrc;

	size_t const hSize = HUF_readDTableX1_wksp(DCtx, cSrc, cSrcSize, workSpace, wkspSize);
	if (HUF_isError(hSize)) return hSize;
	if (hSize >= cSrcSize) return ERROR(srcSize_wrong);
	ip += hSize; cSrcSize -= hSize;

	return HUF_decompress1X1_usingDTable_internal(dst, dstSize, ip, cSrcSize, DCtx, /* bmi2 */ 0);
	}


	size_t HUF_decompress1X1_DCtx(HUF_DTable* DCtx, void* dst, size_t dstSize,
	const void* cSrc, size_t cSrcSize)
	{
	U32 workSpace[HUF_DECOMPRESS_WORKSPACE_SIZE_U32];
	return HUF_decompress1X1_DCtx_wksp(DCtx, dst, dstSize, cSrc, cSrcSize,
	workSpace, sizeof(workSpace));
	}

	size_t HUF_decompress1X1 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
	{
	HUF_CREATE_STATIC_DTABLEX1(DTable, HUF_TABLELOG_MAX);
	return HUF_decompress1X1_DCtx (DTable, dst, dstSize, cSrc, cSrcSize);
	}

	size_t HUF_decompress4X1_usingDTable(
	void* dst, size_t dstSize,
	const void* cSrc, size_t cSrcSize,
	const HUF_DTable* DTable)
	{
	DTableDesc dtd = HUF_getDTableDesc(DTable);
	if (dtd.tableType != 0) return ERROR(GENERIC);
	return HUF_decompress4X1_usingDTable_internal(dst, dstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0);
	}

	static size_t HUF_decompress4X1_DCtx_wksp_bmi2(HUF_DTable* dctx, void* dst, size_t dstSize,
	const void* cSrc, size_t cSrcSize,
	void* workSpace, size_t wkspSize, int bmi2)
	{
	const BYTE* ip = (const BYTE*) cSrc;

	size_t const hSize = HUF_readDTableX1_wksp (dctx, cSrc, cSrcSize,
	workSpace, wkspSize);
	if (HUF_isError(hSize)) return hSize;
	if (hSize >= cSrcSize) return ERROR(srcSize_wrong);
	ip += hSize; cSrcSize -= hSize;

	return HUF_decompress4X1_usingDTable_internal(dst, dstSize, ip, cSrcSize, dctx, bmi2);
	}

	size_t HUF_decompress4X1_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize,
	const void* cSrc, size_t cSrcSize,
	void* workSpace, size_t wkspSize)
	{
	return HUF_decompress4X1_DCtx_wksp_bmi2(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize, 0);
	}


	size_t HUF_decompress4X1_DCtx (HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
	{
	U32 workSpace[HUF_DECOMPRESS_WORKSPACE_SIZE_U32];
	return HUF_decompress4X1_DCtx_wksp(dctx, dst, dstSize, cSrc, cSrcSize,
	workSpace, sizeof(workSpace));
	}
	size_t HUF_decompress4X1 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
	{
	HUF_CREATE_STATIC_DTABLEX1(DTable, HUF_TABLELOG_MAX);
	return HUF_decompress4X1_DCtx(DTable, dst, dstSize, cSrc, cSrcSize);
	}

	#endif /* HUF_FORCE_DECOMPRESS_X2 */


	#ifndef HUF_FORCE_DECOMPRESS_X1

	/* *************************/
	/* double-symbols decoding */
	/* *************************/

	typedef struct { U16 sequence; BYTE nbBits; BYTE length; } HUF_DEltX2; /* double-symbols decoding */
	typedef struct { BYTE symbol; BYTE weight; } sortedSymbol_t;
	typedef U32 rankValCol_t[HUF_TABLELOG_MAX + 1];
	typedef rankValCol_t rankVal_t[HUF_TABLELOG_MAX];


	/* HUF_fillDTableX2Level2() :
	* `rankValOrigin` must be a table of at least (HUF_TABLELOG_MAX + 1) U32 */
	static void HUF_fillDTableX2Level2(HUF_DEltX2* DTable, U32 sizeLog, const U32 consumed,
	const U32* rankValOrigin, const int minWeight,
	const sortedSymbol_t* sortedSymbols, const U32 sortedListSize,
	U32 nbBitsBaseline, U16 baseSeq)
	{
	HUF_DEltX2 DElt;
	U32 rankVal[HUF_TABLELOG_MAX + 1];

	/* get pre-calculated rankVal */
	memcpy(rankVal, rankValOrigin, sizeof(rankVal));

	/* fill skipped values */
	if (minWeight>1) {
	U32 i, skipSize = rankVal[minWeight];
	MEM_writeLE16(&(DElt.sequence), baseSeq);
	DElt.nbBits = (BYTE)(consumed);
	DElt.length = 1;
	for (i = 0; i < skipSize; i++)
	DTable[i] = DElt;
	}

	/* fill DTable */
	{ U32 s; for (s=0; s<sortedListSize; s++) { /* note : sortedSymbols already skipped */
	const U32 symbol = sortedSymbols[s].symbol;
	const U32 weight = sortedSymbols[s].weight;
	const U32 nbBits = nbBitsBaseline - weight;
	const U32 length = 1 << (sizeLog-nbBits);
	const U32 start = rankVal[weight];
	U32 i = start;
	const U32 end = start + length;

	MEM_writeLE16(&(DElt.sequence), (U16)(baseSeq + (symbol << 8)));
	DElt.nbBits = (BYTE)(nbBits + consumed);
	DElt.length = 2;
	do { DTable[i++] = DElt; } while (i<end); /* since length >= 1 */

	rankVal[weight] += length;
	} }
	}


	static void HUF_fillDTableX2(HUF_DEltX2* DTable, const U32 targetLog,
	const sortedSymbol_t* sortedList, const U32 sortedListSize,
	const U32* rankStart, rankVal_t rankValOrigin, const U32 maxWeight,
	const U32 nbBitsBaseline)
	{
	U32 rankVal[HUF_TABLELOG_MAX + 1];
	const int scaleLog = nbBitsBaseline - targetLog; /* note : targetLog >= srcLog, hence scaleLog <= 1 */
	const U32 minBits = nbBitsBaseline - maxWeight;
	U32 s;

	memcpy(rankVal, rankValOrigin, sizeof(rankVal));

	/* fill DTable */
	for (s=0; s<sortedListSize; s++) {
	const U16 symbol = sortedList[s].symbol;
	const U32 weight = sortedList[s].weight;
	const U32 nbBits = nbBitsBaseline - weight;
	const U32 start = rankVal[weight];
	const U32 length = 1 << (targetLog-nbBits);

	if (targetLog-nbBits >= minBits) { /* enough room for a second symbol */
	U32 sortedRank;
	int minWeight = nbBits + scaleLog;
	if (minWeight < 1) minWeight = 1;
	sortedRank = rankStart[minWeight];
	HUF_fillDTableX2Level2(DTable+start, targetLog-nbBits, nbBits,
	rankValOrigin[nbBits], minWeight,
	sortedList+sortedRank, sortedListSize-sortedRank,
	nbBitsBaseline, symbol);
	} else {
	HUF_DEltX2 DElt;
	MEM_writeLE16(&(DElt.sequence), symbol);
	DElt.nbBits = (BYTE)(nbBits);
	DElt.length = 1;
	{ U32 const end = start + length;
	U32 u;
	for (u = start; u < end; u++) DTable[u] = DElt;
	} }
	rankVal[weight] += length;
	}
	}

	size_t HUF_readDTableX2_wksp(HUF_DTable* DTable,
	const void* src, size_t srcSize,
	void* workSpace, size_t wkspSize)
	{
	U32 tableLog, maxW, sizeOfSort, nbSymbols;
	DTableDesc dtd = HUF_getDTableDesc(DTable);
	U32 const maxTableLog = dtd.maxTableLog;
	size_t iSize;
	void* dtPtr = DTable+1; /* force compiler to avoid strict-aliasing */
	HUF_DEltX2* const dt = (HUF_DEltX2*)dtPtr;
	U32 *rankStart;

	rankValCol_t* rankVal;
	U32* rankStats;
	U32* rankStart0;
	sortedSymbol_t* sortedSymbol;
	BYTE* weightList;
	size_t spaceUsed32 = 0;

	rankVal = (rankValCol_t )((U32 )workSpace + spaceUsed32);
	spaceUsed32 += (sizeof(rankValCol_t) * HUF_TABLELOG_MAX) >> 2;
	rankStats = (U32 *)workSpace + spaceUsed32;
	spaceUsed32 += HUF_TABLELOG_MAX + 1;
	rankStart0 = (U32 *)workSpace + spaceUsed32;
	spaceUsed32 += HUF_TABLELOG_MAX + 2;
	sortedSymbol = (sortedSymbol_t )workSpace + (spaceUsed32 sizeof(U32)) / sizeof(sortedSymbol_t);
	spaceUsed32 += HUF_ALIGN(sizeof(sortedSymbol_t) * (HUF_SYMBOLVALUE_MAX + 1), sizeof(U32)) >> 2;
	weightList = (BYTE )((U32 )workSpace + spaceUsed32);
	spaceUsed32 += HUF_ALIGN(HUF_SYMBOLVALUE_MAX + 1, sizeof(U32)) >> 2;

	if ((spaceUsed32 << 2) > wkspSize) return ERROR(tableLog_tooLarge);

	rankStart = rankStart0 + 1;
	memset(rankStats, 0, sizeof(U32) * (2 * HUF_TABLELOG_MAX + 2 + 1));

	DEBUG_STATIC_ASSERT(sizeof(HUF_DEltX2) == sizeof(HUF_DTable)); /* if compiler fails here, assertion is wrong */
	if (maxTableLog > HUF_TABLELOG_MAX) return ERROR(tableLog_tooLarge);
	/* memset(weightList, 0, sizeof(weightList)); / / is not necessary, even though some analyzer complain ... */

	iSize = HUF_readStats(weightList, HUF_SYMBOLVALUE_MAX + 1, rankStats, &nbSymbols, &tableLog, src, srcSize);
	if (HUF_isError(iSize)) return iSize;

	/* check result */
	if (tableLog > maxTableLog) return ERROR(tableLog_tooLarge); /* DTable can't fit code depth */

	/* find maxWeight */
	for (maxW = tableLog; rankStats[maxW]==0; maxW--) {} /* necessarily finds a solution before 0 */

	/* Get start index of each weight */
	{ U32 w, nextRankStart = 0;
	for (w=1; w<maxW+1; w++) {
	U32 current = nextRankStart;
	nextRankStart += rankStats[w];
	rankStart[w] = current;
	}
	rankStart[0] = nextRankStart; /* put all 0w symbols at the end of sorted list*/
	sizeOfSort = nextRankStart;
	}

	/* sort symbols by weight */
	{ U32 s;
	for (s=0; s<nbSymbols; s++) {
	U32 const w = weightList[s];
	U32 const r = rankStart[w]++;
	sortedSymbol[r].symbol = (BYTE)s;
	sortedSymbol[r].weight = (BYTE)w;
	}
	rankStart[0] = 0; /* forget 0w symbols; this is beginning of weight(1) */
	}

	/* Build rankVal */
	{ U32* const rankVal0 = rankVal[0];
	{ int const rescale = (maxTableLog-tableLog) - 1; /* tableLog <= maxTableLog */
	U32 nextRankVal = 0;
	U32 w;
	for (w=1; w<maxW+1; w++) {
	U32 current = nextRankVal;
	nextRankVal += rankStats[w] << (w+rescale);
	rankVal0[w] = current;
	} }
	{ U32 const minBits = tableLog+1 - maxW;
	U32 consumed;
	for (consumed = minBits; consumed < maxTableLog - minBits + 1; consumed++) {
	U32* const rankValPtr = rankVal[consumed];
	U32 w;
	for (w = 1; w < maxW+1; w++) {
	rankValPtr[w] = rankVal0[w] >> consumed;
	} } } }

	HUF_fillDTableX2(dt, maxTableLog,
	sortedSymbol, sizeOfSort,
	rankStart0, rankVal, maxW,
	tableLog+1);

	dtd.tableLog = (BYTE)maxTableLog;
	dtd.tableType = 1;
	memcpy(DTable, &dtd, sizeof(dtd));
	return iSize;
	}

	size_t HUF_readDTableX2(HUF_DTable* DTable, const void* src, size_t srcSize)
	{
	U32 workSpace[HUF_DECOMPRESS_WORKSPACE_SIZE_U32];
	return HUF_readDTableX2_wksp(DTable, src, srcSize,
	workSpace, sizeof(workSpace));
	}


	FORCE_INLINE_TEMPLATE U32
	HUF_decodeSymbolX2(void* op, BIT_DStream_t* DStream, const HUF_DEltX2* dt, const U32 dtLog)
	{
	size_t const val = BIT_lookBitsFast(DStream, dtLog); /* note : dtLog >= 1 */
	memcpy(op, dt+val, 2);
	BIT_skipBits(DStream, dt[val].nbBits);
	return dt[val].length;
	}

	FORCE_INLINE_TEMPLATE U32
	HUF_decodeLastSymbolX2(void* op, BIT_DStream_t* DStream, const HUF_DEltX2* dt, const U32 dtLog)
	{
	size_t const val = BIT_lookBitsFast(DStream, dtLog); /* note : dtLog >= 1 */
	memcpy(op, dt+val, 1);
	if (dt[val].length==1) BIT_skipBits(DStream, dt[val].nbBits);
	else {
	if (DStream->bitsConsumed < (sizeof(DStream->bitContainer)*8)) {
	BIT_skipBits(DStream, dt[val].nbBits);
	if (DStream->bitsConsumed > (sizeof(DStream->bitContainer)*8))
	/* ugly hack; works only because it's the last symbol. Note : can't easily extract nbBits from just this symbol */
	DStream->bitsConsumed = (sizeof(DStream->bitContainer)*8);
	} }
	return 1;
	}

	#define HUF_DECODE_SYMBOLX2_0(ptr, DStreamPtr) \
	ptr += HUF_decodeSymbolX2(ptr, DStreamPtr, dt, dtLog)

	#define HUF_DECODE_SYMBOLX2_1(ptr, DStreamPtr) \
	if (MEM_64bits() \|\| (HUF_TABLELOG_MAX<=12)) \
	ptr += HUF_decodeSymbolX2(ptr, DStreamPtr, dt, dtLog)

	#define HUF_DECODE_SYMBOLX2_2(ptr, DStreamPtr) \
	if (MEM_64bits()) \
	ptr += HUF_decodeSymbolX2(ptr, DStreamPtr, dt, dtLog)

	HINT_INLINE size_t
	HUF_decodeStreamX2(BYTE* p, BIT_DStream_t* bitDPtr, BYTE* const pEnd,
	const HUF_DEltX2* const dt, const U32 dtLog)
	{
	BYTE* const pStart = p;

	/* up to 8 symbols at a time */
	while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) & (p < pEnd-(sizeof(bitDPtr->bitContainer)-1))) {
	HUF_DECODE_SYMBOLX2_2(p, bitDPtr);
	HUF_DECODE_SYMBOLX2_1(p, bitDPtr);
	HUF_DECODE_SYMBOLX2_2(p, bitDPtr);
	HUF_DECODE_SYMBOLX2_0(p, bitDPtr);
	}

	/* closer to end : up to 2 symbols at a time */
	while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) & (p <= pEnd-2))
	HUF_DECODE_SYMBOLX2_0(p, bitDPtr);

	while (p <= pEnd-2)
	HUF_DECODE_SYMBOLX2_0(p, bitDPtr); /* no need to reload : reached the end of DStream */

	if (p < pEnd)
	p += HUF_decodeLastSymbolX2(p, bitDPtr, dt, dtLog);

	return p-pStart;
	}

	FORCE_INLINE_TEMPLATE size_t
	HUF_decompress1X2_usingDTable_internal_body(
	void* dst, size_t dstSize,
	const void* cSrc, size_t cSrcSize,
	const HUF_DTable* DTable)
	{
	BIT_DStream_t bitD;

	/* Init */
	CHECK_F( BIT_initDStream(&bitD, cSrc, cSrcSize) );

	/* decode */
	{ BYTE* const ostart = (BYTE*) dst;
	BYTE* const oend = ostart + dstSize;
	const void* const dtPtr = DTable+1; /* force compiler to not use strict-aliasing */
	const HUF_DEltX2* const dt = (const HUF_DEltX2*)dtPtr;
	DTableDesc const dtd = HUF_getDTableDesc(DTable);
	HUF_decodeStreamX2(ostart, &bitD, oend, dt, dtd.tableLog);
	}

	/* check */
	if (!BIT_endOfDStream(&bitD)) return ERROR(corruption_detected);

	/* decoded size */
	return dstSize;
	}

	FORCE_INLINE_TEMPLATE size_t
	HUF_decompress4X2_usingDTable_internal_body(
	void* dst, size_t dstSize,
	const void* cSrc, size_t cSrcSize,
	const HUF_DTable* DTable)
	{
	if (cSrcSize < 10) return ERROR(corruption_detected); /* strict minimum : jump table + 1 byte per stream */

	{ const BYTE* const istart = (const BYTE*) cSrc;
	BYTE* const ostart = (BYTE*) dst;
	BYTE* const oend = ostart + dstSize;
	BYTE* const olimit = oend - (sizeof(size_t)-1);
	const void* const dtPtr = DTable+1;
	const HUF_DEltX2* const dt = (const HUF_DEltX2*)dtPtr;

	/* Init */
	BIT_DStream_t bitD1;
	BIT_DStream_t bitD2;
	BIT_DStream_t bitD3;
	BIT_DStream_t bitD4;
	size_t const length1 = MEM_readLE16(istart);
	size_t const length2 = MEM_readLE16(istart+2);
	size_t const length3 = MEM_readLE16(istart+4);
	size_t const length4 = cSrcSize - (length1 + length2 + length3 + 6);
	const BYTE* const istart1 = istart + 6; /* jumpTable */
	const BYTE* const istart2 = istart1 + length1;
	const BYTE* const istart3 = istart2 + length2;
	const BYTE* const istart4 = istart3 + length3;
	size_t const segmentSize = (dstSize+3) / 4;
	BYTE* const opStart2 = ostart + segmentSize;
	BYTE* const opStart3 = opStart2 + segmentSize;
	BYTE* const opStart4 = opStart3 + segmentSize;
	BYTE* op1 = ostart;
	BYTE* op2 = opStart2;
	BYTE* op3 = opStart3;
	BYTE* op4 = opStart4;
	U32 endSignal = 1;
	DTableDesc const dtd = HUF_getDTableDesc(DTable);
	U32 const dtLog = dtd.tableLog;

	if (length4 > cSrcSize) return ERROR(corruption_detected); /* overflow */
	CHECK_F( BIT_initDStream(&bitD1, istart1, length1) );
	CHECK_F( BIT_initDStream(&bitD2, istart2, length2) );
	CHECK_F( BIT_initDStream(&bitD3, istart3, length3) );
	CHECK_F( BIT_initDStream(&bitD4, istart4, length4) );

	/* 16-32 symbols per loop (4-8 symbols per stream) */
	for ( ; (endSignal) & (op4 < olimit); ) {
	#if defined(__clang__) && (defined(__x86_64__) \|\| defined(__i386__))
	HUF_DECODE_SYMBOLX2_2(op1, &bitD1);
	HUF_DECODE_SYMBOLX2_1(op1, &bitD1);
	HUF_DECODE_SYMBOLX2_2(op1, &bitD1);
	HUF_DECODE_SYMBOLX2_0(op1, &bitD1);
	HUF_DECODE_SYMBOLX2_2(op2, &bitD2);
	HUF_DECODE_SYMBOLX2_1(op2, &bitD2);
	HUF_DECODE_SYMBOLX2_2(op2, &bitD2);
	HUF_DECODE_SYMBOLX2_0(op2, &bitD2);
	endSignal &= BIT_reloadDStreamFast(&bitD1) == BIT_DStream_unfinished;
	endSignal &= BIT_reloadDStreamFast(&bitD2) == BIT_DStream_unfinished;
	HUF_DECODE_SYMBOLX2_2(op3, &bitD3);
	HUF_DECODE_SYMBOLX2_1(op3, &bitD3);
	HUF_DECODE_SYMBOLX2_2(op3, &bitD3);
	HUF_DECODE_SYMBOLX2_0(op3, &bitD3);
	HUF_DECODE_SYMBOLX2_2(op4, &bitD4);
	HUF_DECODE_SYMBOLX2_1(op4, &bitD4);
	HUF_DECODE_SYMBOLX2_2(op4, &bitD4);
	HUF_DECODE_SYMBOLX2_0(op4, &bitD4);
	endSignal &= BIT_reloadDStreamFast(&bitD3) == BIT_DStream_unfinished;
	endSignal &= BIT_reloadDStreamFast(&bitD4) == BIT_DStream_unfinished;
	#else
	HUF_DECODE_SYMBOLX2_2(op1, &bitD1);
	HUF_DECODE_SYMBOLX2_2(op2, &bitD2);
	HUF_DECODE_SYMBOLX2_2(op3, &bitD3);
	HUF_DECODE_SYMBOLX2_2(op4, &bitD4);
	HUF_DECODE_SYMBOLX2_1(op1, &bitD1);
	HUF_DECODE_SYMBOLX2_1(op2, &bitD2);
	HUF_DECODE_SYMBOLX2_1(op3, &bitD3);
	HUF_DECODE_SYMBOLX2_1(op4, &bitD4);
	HUF_DECODE_SYMBOLX2_2(op1, &bitD1);
	HUF_DECODE_SYMBOLX2_2(op2, &bitD2);
	HUF_DECODE_SYMBOLX2_2(op3, &bitD3);
	HUF_DECODE_SYMBOLX2_2(op4, &bitD4);
	HUF_DECODE_SYMBOLX2_0(op1, &bitD1);
	HUF_DECODE_SYMBOLX2_0(op2, &bitD2);
	HUF_DECODE_SYMBOLX2_0(op3, &bitD3);
	HUF_DECODE_SYMBOLX2_0(op4, &bitD4);
	endSignal = (U32)LIKELY(
	(BIT_reloadDStreamFast(&bitD1) == BIT_DStream_unfinished)
	& (BIT_reloadDStreamFast(&bitD2) == BIT_DStream_unfinished)
	& (BIT_reloadDStreamFast(&bitD3) == BIT_DStream_unfinished)
	& (BIT_reloadDStreamFast(&bitD4) == BIT_DStream_unfinished));
	#endif
	}

	/* check corruption */
	if (op1 > opStart2) return ERROR(corruption_detected);
	if (op2 > opStart3) return ERROR(corruption_detected);
	if (op3 > opStart4) return ERROR(corruption_detected);
	/* note : op4 already verified within main loop */

	/* finish bitStreams one by one */
	HUF_decodeStreamX2(op1, &bitD1, opStart2, dt, dtLog);
	HUF_decodeStreamX2(op2, &bitD2, opStart3, dt, dtLog);
	HUF_decodeStreamX2(op3, &bitD3, opStart4, dt, dtLog);
	HUF_decodeStreamX2(op4, &bitD4, oend, dt, dtLog);

	/* check */
	{ U32 const endCheck = BIT_endOfDStream(&bitD1) & BIT_endOfDStream(&bitD2) & BIT_endOfDStream(&bitD3) & BIT_endOfDStream(&bitD4);
	if (!endCheck) return ERROR(corruption_detected); }

	/* decoded size */
	return dstSize;
	}
	}

	HUF_DGEN(HUF_decompress1X2_usingDTable_internal)
	HUF_DGEN(HUF_decompress4X2_usingDTable_internal)

	size_t HUF_decompress1X2_usingDTable(
	void* dst, size_t dstSize,
	const void* cSrc, size_t cSrcSize,
	const HUF_DTable* DTable)
	{
	DTableDesc dtd = HUF_getDTableDesc(DTable);
	if (dtd.tableType != 1) return ERROR(GENERIC);
	return HUF_decompress1X2_usingDTable_internal(dst, dstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0);
	}

	size_t HUF_decompress1X2_DCtx_wksp(HUF_DTable* DCtx, void* dst, size_t dstSize,
	const void* cSrc, size_t cSrcSize,
	void* workSpace, size_t wkspSize)
	{
	const BYTE* ip = (const BYTE*) cSrc;

	size_t const hSize = HUF_readDTableX2_wksp(DCtx, cSrc, cSrcSize,
	workSpace, wkspSize);
	if (HUF_isError(hSize)) return hSize;
	if (hSize >= cSrcSize) return ERROR(srcSize_wrong);
	ip += hSize; cSrcSize -= hSize;

	return HUF_decompress1X2_usingDTable_internal(dst, dstSize, ip, cSrcSize, DCtx, /* bmi2 */ 0);
	}


	size_t HUF_decompress1X2_DCtx(HUF_DTable* DCtx, void* dst, size_t dstSize,
	const void* cSrc, size_t cSrcSize)
	{
	U32 workSpace[HUF_DECOMPRESS_WORKSPACE_SIZE_U32];
	return HUF_decompress1X2_DCtx_wksp(DCtx, dst, dstSize, cSrc, cSrcSize,
	workSpace, sizeof(workSpace));
	}

	size_t HUF_decompress1X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
	{
	HUF_CREATE_STATIC_DTABLEX2(DTable, HUF_TABLELOG_MAX);
	return HUF_decompress1X2_DCtx(DTable, dst, dstSize, cSrc, cSrcSize);
	}

	size_t HUF_decompress4X2_usingDTable(
	void* dst, size_t dstSize,
	const void* cSrc, size_t cSrcSize,
	const HUF_DTable* DTable)
	{
	DTableDesc dtd = HUF_getDTableDesc(DTable);
	if (dtd.tableType != 1) return ERROR(GENERIC);
	return HUF_decompress4X2_usingDTable_internal(dst, dstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0);
	}

	static size_t HUF_decompress4X2_DCtx_wksp_bmi2(HUF_DTable* dctx, void* dst, size_t dstSize,
	const void* cSrc, size_t cSrcSize,
	void* workSpace, size_t wkspSize, int bmi2)
	{
	const BYTE* ip = (const BYTE*) cSrc;

	size_t hSize = HUF_readDTableX2_wksp(dctx, cSrc, cSrcSize,
	workSpace, wkspSize);
	if (HUF_isError(hSize)) return hSize;
	if (hSize >= cSrcSize) return ERROR(srcSize_wrong);
	ip += hSize; cSrcSize -= hSize;

	return HUF_decompress4X2_usingDTable_internal(dst, dstSize, ip, cSrcSize, dctx, bmi2);
	}

	size_t HUF_decompress4X2_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize,
	const void* cSrc, size_t cSrcSize,
	void* workSpace, size_t wkspSize)
	{
	return HUF_decompress4X2_DCtx_wksp_bmi2(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize, /* bmi2 */ 0);
	}


	size_t HUF_decompress4X2_DCtx(HUF_DTable* dctx, void* dst, size_t dstSize,
	const void* cSrc, size_t cSrcSize)
	{
	U32 workSpace[HUF_DECOMPRESS_WORKSPACE_SIZE_U32];
	return HUF_decompress4X2_DCtx_wksp(dctx, dst, dstSize, cSrc, cSrcSize,
	workSpace, sizeof(workSpace));
	}

	size_t HUF_decompress4X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
	{
	HUF_CREATE_STATIC_DTABLEX2(DTable, HUF_TABLELOG_MAX);
	return HUF_decompress4X2_DCtx(DTable, dst, dstSize, cSrc, cSrcSize);
	}

	#endif /* HUF_FORCE_DECOMPRESS_X1 */


	/* ***********************************/
	/* Universal decompression selectors */
	/* ***********************************/

	size_t HUF_decompress1X_usingDTable(void* dst, size_t maxDstSize,
	const void* cSrc, size_t cSrcSize,
	const HUF_DTable* DTable)
	{
	DTableDesc const dtd = HUF_getDTableDesc(DTable);
	#if defined(HUF_FORCE_DECOMPRESS_X1)
	(void)dtd;
	assert(dtd.tableType == 0);
	return HUF_decompress1X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0);
	#elif defined(HUF_FORCE_DECOMPRESS_X2)
	(void)dtd;
	assert(dtd.tableType == 1);
	return HUF_decompress1X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0);
	#else
	return dtd.tableType ? HUF_decompress1X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0) :
	HUF_decompress1X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0);
	#endif
	}

	size_t HUF_decompress4X_usingDTable(void* dst, size_t maxDstSize,
	const void* cSrc, size_t cSrcSize,
	const HUF_DTable* DTable)
	{
	DTableDesc const dtd = HUF_getDTableDesc(DTable);
	#if defined(HUF_FORCE_DECOMPRESS_X1)
	(void)dtd;
	assert(dtd.tableType == 0);
	return HUF_decompress4X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0);
	#elif defined(HUF_FORCE_DECOMPRESS_X2)
	(void)dtd;
	assert(dtd.tableType == 1);
	return HUF_decompress4X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0);
	#else
	return dtd.tableType ? HUF_decompress4X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0) :
	HUF_decompress4X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0);
	#endif
	}


	#if !defined(HUF_FORCE_DECOMPRESS_X1) && !defined(HUF_FORCE_DECOMPRESS_X2)
	typedef struct { U32 tableTime; U32 decode256Time; } algo_time_t;
	static const algo_time_t algoTime[16 /* Quantization /][3 / single, double, quad */] =
	{
	/* single, double, quad */
	{{0,0}, {1,1}, {2,2}}, /* Q==0 : impossible */
	{{0,0}, {1,1}, {2,2}}, /* Q==1 : impossible */
	{{ 38,130}, {1313, 74}, {2151, 38}}, /* Q == 2 : 12-18% */
	{{ 448,128}, {1353, 74}, {2238, 41}}, /* Q == 3 : 18-25% */
	{{ 556,128}, {1353, 74}, {2238, 47}}, /* Q == 4 : 25-32% */
	{{ 714,128}, {1418, 74}, {2436, 53}}, /* Q == 5 : 32-38% */
	{{ 883,128}, {1437, 74}, {2464, 61}}, /* Q == 6 : 38-44% */
	{{ 897,128}, {1515, 75}, {2622, 68}}, /* Q == 7 : 44-50% */
	{{ 926,128}, {1613, 75}, {2730, 75}}, /* Q == 8 : 50-56% */
	{{ 947,128}, {1729, 77}, {3359, 77}}, /* Q == 9 : 56-62% */
	{{1107,128}, {2083, 81}, {4006, 84}}, /* Q ==10 : 62-69% */
	{{1177,128}, {2379, 87}, {4785, 88}}, /* Q ==11 : 69-75% */
	{{1242,128}, {2415, 93}, {5155, 84}}, /* Q ==12 : 75-81% */
	{{1349,128}, {2644,106}, {5260,106}}, /* Q ==13 : 81-87% */
	{{1455,128}, {2422,124}, {4174,124}}, /* Q ==14 : 87-93% */
	{{ 722,128}, {1891,145}, {1936,146}}, /* Q ==15 : 93-99% */
	};
	#endif

	/** HUF_selectDecoder() :
	* Tells which decoder is likely to decode faster,
	* based on a set of pre-computed metrics.
	* @return : 0==HUF_decompress4X1, 1==HUF_decompress4X2 .
	* Assumption : 0 < dstSize <= 128 KB */
	U32 HUF_selectDecoder (size_t dstSize, size_t cSrcSize)
	{
	assert(dstSize > 0);
	assert(dstSize <= 128*1024);
	#if defined(HUF_FORCE_DECOMPRESS_X1)
	(void)dstSize;
	(void)cSrcSize;
	return 0;
	#elif defined(HUF_FORCE_DECOMPRESS_X2)
	(void)dstSize;
	(void)cSrcSize;
	return 1;
	#else
	/* decoder timing evaluation */
	{ U32 const Q = (cSrcSize >= dstSize) ? 15 : (U32)(cSrcSize * 16 / dstSize); /* Q < 16 */
	U32 const D256 = (U32)(dstSize >> 8);
	U32 const DTime0 = algoTime[Q][0].tableTime + (algoTime[Q][0].decode256Time * D256);
	U32 DTime1 = algoTime[Q][1].tableTime + (algoTime[Q][1].decode256Time * D256);
	DTime1 += DTime1 >> 3; /* advantage to algorithm using less memory, to reduce cache eviction */
	return DTime1 < DTime0;
	}
	#endif
	}


	typedef size_t (decompressionAlgo)(void dst, size_t dstSize, const void* cSrc, size_t cSrcSize);

	size_t HUF_decompress (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
	{
	#if !defined(HUF_FORCE_DECOMPRESS_X1) && !defined(HUF_FORCE_DECOMPRESS_X2)
	static const decompressionAlgo decompress[2] = { HUF_decompress4X1, HUF_decompress4X2 };
	#endif

	/* validation checks */
	if (dstSize == 0) return ERROR(dstSize_tooSmall);
	if (cSrcSize > dstSize) return ERROR(corruption_detected); /* invalid */
	if (cSrcSize == dstSize) { memcpy(dst, cSrc, dstSize); return dstSize; } /* not compressed */
	if (cSrcSize == 1) { memset(dst, (const BYTE)cSrc, dstSize); return dstSize; } /* RLE */

	{ U32 const algoNb = HUF_selectDecoder(dstSize, cSrcSize);
	#if defined(HUF_FORCE_DECOMPRESS_X1)
	(void)algoNb;
	assert(algoNb == 0);
	return HUF_decompress4X1(dst, dstSize, cSrc, cSrcSize);
	#elif defined(HUF_FORCE_DECOMPRESS_X2)
	(void)algoNb;
	assert(algoNb == 1);
	return HUF_decompress4X2(dst, dstSize, cSrc, cSrcSize);
	#else
	return decompress[algoNb](dst, dstSize, cSrc, cSrcSize);
	#endif
	}
	}

	size_t HUF_decompress4X_DCtx (HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
	{
	/* validation checks */
	if (dstSize == 0) return ERROR(dstSize_tooSmall);
	if (cSrcSize > dstSize) return ERROR(corruption_detected); /* invalid */
	if (cSrcSize == dstSize) { memcpy(dst, cSrc, dstSize); return dstSize; } /* not compressed */
	if (cSrcSize == 1) { memset(dst, (const BYTE)cSrc, dstSize); return dstSize; } /* RLE */

	{ U32 const algoNb = HUF_selectDecoder(dstSize, cSrcSize);
	#if defined(HUF_FORCE_DECOMPRESS_X1)
	(void)algoNb;
	assert(algoNb == 0);
	return HUF_decompress4X1_DCtx(dctx, dst, dstSize, cSrc, cSrcSize);
	#elif defined(HUF_FORCE_DECOMPRESS_X2)
	(void)algoNb;
	assert(algoNb == 1);
	return HUF_decompress4X2_DCtx(dctx, dst, dstSize, cSrc, cSrcSize);
	#else
	return algoNb ? HUF_decompress4X2_DCtx(dctx, dst, dstSize, cSrc, cSrcSize) :
	HUF_decompress4X1_DCtx(dctx, dst, dstSize, cSrc, cSrcSize) ;
	#endif
	}
	}

	size_t HUF_decompress4X_hufOnly(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
	{
	U32 workSpace[HUF_DECOMPRESS_WORKSPACE_SIZE_U32];
	return HUF_decompress4X_hufOnly_wksp(dctx, dst, dstSize, cSrc, cSrcSize,
	workSpace, sizeof(workSpace));
	}


	size_t HUF_decompress4X_hufOnly_wksp(HUF_DTable* dctx, void* dst,
	size_t dstSize, const void* cSrc,
	size_t cSrcSize, void* workSpace,
	size_t wkspSize)
	{
	/* validation checks */
	if (dstSize == 0) return ERROR(dstSize_tooSmall);
	if (cSrcSize == 0) return ERROR(corruption_detected);

	{ U32 const algoNb = HUF_selectDecoder(dstSize, cSrcSize);
	#if defined(HUF_FORCE_DECOMPRESS_X1)
	(void)algoNb;
	assert(algoNb == 0);
	return HUF_decompress4X1_DCtx_wksp(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize);
	#elif defined(HUF_FORCE_DECOMPRESS_X2)
	(void)algoNb;
	assert(algoNb == 1);
	return HUF_decompress4X2_DCtx_wksp(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize);
	#else
	return algoNb ? HUF_decompress4X2_DCtx_wksp(dctx, dst, dstSize, cSrc,
	cSrcSize, workSpace, wkspSize):
	HUF_decompress4X1_DCtx_wksp(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize);
	#endif
	}
	}

	size_t HUF_decompress1X_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize,
	const void* cSrc, size_t cSrcSize,
	void* workSpace, size_t wkspSize)
	{
	/* validation checks */
	if (dstSize == 0) return ERROR(dstSize_tooSmall);
	if (cSrcSize > dstSize) return ERROR(corruption_detected); /* invalid */
	if (cSrcSize == dstSize) { memcpy(dst, cSrc, dstSize); return dstSize; } /* not compressed */
	if (cSrcSize == 1) { memset(dst, (const BYTE)cSrc, dstSize); return dstSize; } /* RLE */

	{ U32 const algoNb = HUF_selectDecoder(dstSize, cSrcSize);
	#if defined(HUF_FORCE_DECOMPRESS_X1)
	(void)algoNb;
	assert(algoNb == 0);
	return HUF_decompress1X1_DCtx_wksp(dctx, dst, dstSize, cSrc,
	cSrcSize, workSpace, wkspSize);
	#elif defined(HUF_FORCE_DECOMPRESS_X2)
	(void)algoNb;
	assert(algoNb == 1);
	return HUF_decompress1X2_DCtx_wksp(dctx, dst, dstSize, cSrc,
	cSrcSize, workSpace, wkspSize);
	#else
	return algoNb ? HUF_decompress1X2_DCtx_wksp(dctx, dst, dstSize, cSrc,
	cSrcSize, workSpace, wkspSize):
	HUF_decompress1X1_DCtx_wksp(dctx, dst, dstSize, cSrc,
	cSrcSize, workSpace, wkspSize);
	#endif
	}
	}

	size_t HUF_decompress1X_DCtx(HUF_DTable* dctx, void* dst, size_t dstSize,
	const void* cSrc, size_t cSrcSize)
	{
	U32 workSpace[HUF_DECOMPRESS_WORKSPACE_SIZE_U32];
	return HUF_decompress1X_DCtx_wksp(dctx, dst, dstSize, cSrc, cSrcSize,
	workSpace, sizeof(workSpace));
	}


	size_t HUF_decompress1X_usingDTable_bmi2(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable, int bmi2)
	{
	DTableDesc const dtd = HUF_getDTableDesc(DTable);
	#if defined(HUF_FORCE_DECOMPRESS_X1)
	(void)dtd;
	assert(dtd.tableType == 0);
	return HUF_decompress1X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, bmi2);
	#elif defined(HUF_FORCE_DECOMPRESS_X2)
	(void)dtd;
	assert(dtd.tableType == 1);
	return HUF_decompress1X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, bmi2);
	#else
	return dtd.tableType ? HUF_decompress1X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, bmi2) :
	HUF_decompress1X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, bmi2);
	#endif
	}

	#ifndef HUF_FORCE_DECOMPRESS_X2
	size_t HUF_decompress1X1_DCtx_wksp_bmi2(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize, int bmi2)
	{
	const BYTE* ip = (const BYTE*) cSrc;

	size_t const hSize = HUF_readDTableX1_wksp(dctx, cSrc, cSrcSize, workSpace, wkspSize);
	if (HUF_isError(hSize)) return hSize;
	if (hSize >= cSrcSize) return ERROR(srcSize_wrong);
	ip += hSize; cSrcSize -= hSize;

	return HUF_decompress1X1_usingDTable_internal(dst, dstSize, ip, cSrcSize, dctx, bmi2);
	}
	#endif

	size_t HUF_decompress4X_usingDTable_bmi2(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable, int bmi2)
	{
	DTableDesc const dtd = HUF_getDTableDesc(DTable);
	#if defined(HUF_FORCE_DECOMPRESS_X1)
	(void)dtd;
	assert(dtd.tableType == 0);
	return HUF_decompress4X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, bmi2);
	#elif defined(HUF_FORCE_DECOMPRESS_X2)
	(void)dtd;
	assert(dtd.tableType == 1);
	return HUF_decompress4X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, bmi2);
	#else
	return dtd.tableType ? HUF_decompress4X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, bmi2) :
	HUF_decompress4X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, bmi2);
	#endif
	}

	size_t HUF_decompress4X_hufOnly_wksp_bmi2(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize, int bmi2)
	{
	/* validation checks */
	if (dstSize == 0) return ERROR(dstSize_tooSmall);
	if (cSrcSize == 0) return ERROR(corruption_detected);

	{ U32 const algoNb = HUF_selectDecoder(dstSize, cSrcSize);
	#if defined(HUF_FORCE_DECOMPRESS_X1)
	(void)algoNb;
	assert(algoNb == 0);
	return HUF_decompress4X1_DCtx_wksp_bmi2(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize, bmi2);
	#elif defined(HUF_FORCE_DECOMPRESS_X2)
	(void)algoNb;
	assert(algoNb == 1);
	return HUF_decompress4X2_DCtx_wksp_bmi2(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize, bmi2);
	#else
	return algoNb ? HUF_decompress4X2_DCtx_wksp_bmi2(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize, bmi2) :
	HUF_decompress4X1_DCtx_wksp_bmi2(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize, bmi2);
	#endif
	}
	}
	/** ended inlining decompress/huf_decompress.c **/
	/** start inlining decompress/zstd_ddict.c **/
	/*
	* Copyright (c) 2016-2020, Yann Collet, Facebook, Inc.
	* All rights reserved.
	*
	* This source code is licensed under both the BSD-style license (found in the
	* LICENSE file in the root directory of this source tree) and the GPLv2 (found
	* in the COPYING file in the root directory of this source tree).
	* You may select, at your option, one of the above-listed licenses.
	*/

	/* zstd_ddict.c :
	* concentrates all logic that needs to know the internals of ZSTD_DDict object */

	/-******************************************************
	* Dependencies
	*********************************************************/
	#include <string.h> /* memcpy, memmove, memset */
	/** skipping file: ../common/cpu.h **/
	/** skipping file: ../common/mem.h **/
	#define FSE_STATIC_LINKING_ONLY
	/** skipping file: ../common/fse.h **/
	#define HUF_STATIC_LINKING_ONLY
	/** skipping file: ../common/huf.h **/
	/** start inlining zstd_decompress_internal.h **/
	/*
	* Copyright (c) 2016-2020, Yann Collet, Facebook, Inc.
	* All rights reserved.
	*
	* This source code is licensed under both the BSD-style license (found in the
	* LICENSE file in the root directory of this source tree) and the GPLv2 (found
	* in the COPYING file in the root directory of this source tree).
	* You may select, at your option, one of the above-listed licenses.
	*/


	/* zstd_decompress_internal:
	* objects and definitions shared within lib/decompress modules */

	#ifndef ZSTD_DECOMPRESS_INTERNAL_H
	#define ZSTD_DECOMPRESS_INTERNAL_H


	/-******************************************************
	* Dependencies
	*********************************************************/
	/** skipping file: ../common/mem.h **/
	/** skipping file: ../common/zstd_internal.h **/



	/-******************************************************
	* Constants
	*********************************************************/
	static const U32 LL_base[MaxLL+1] = {
	0, 1, 2, 3, 4, 5, 6, 7,
	8, 9, 10, 11, 12, 13, 14, 15,
	16, 18, 20, 22, 24, 28, 32, 40,
	48, 64, 0x80, 0x100, 0x200, 0x400, 0x800, 0x1000,
	0x2000, 0x4000, 0x8000, 0x10000 };

	static const U32 OF_base[MaxOff+1] = {
	0, 1, 1, 5, 0xD, 0x1D, 0x3D, 0x7D,
	0xFD, 0x1FD, 0x3FD, 0x7FD, 0xFFD, 0x1FFD, 0x3FFD, 0x7FFD,
	0xFFFD, 0x1FFFD, 0x3FFFD, 0x7FFFD, 0xFFFFD, 0x1FFFFD, 0x3FFFFD, 0x7FFFFD,
	0xFFFFFD, 0x1FFFFFD, 0x3FFFFFD, 0x7FFFFFD, 0xFFFFFFD, 0x1FFFFFFD, 0x3FFFFFFD, 0x7FFFFFFD };

	static const U32 OF_bits[MaxOff+1] = {
	0, 1, 2, 3, 4, 5, 6, 7,
	8, 9, 10, 11, 12, 13, 14, 15,
	16, 17, 18, 19, 20, 21, 22, 23,
	24, 25, 26, 27, 28, 29, 30, 31 };

	static const U32 ML_base[MaxML+1] = {
	3, 4, 5, 6, 7, 8, 9, 10,
	11, 12, 13, 14, 15, 16, 17, 18,
	19, 20, 21, 22, 23, 24, 25, 26,
	27, 28, 29, 30, 31, 32, 33, 34,
	35, 37, 39, 41, 43, 47, 51, 59,
	67, 83, 99, 0x83, 0x103, 0x203, 0x403, 0x803,
	0x1003, 0x2003, 0x4003, 0x8003, 0x10003 };


	/-******************************************************
	* Decompression types
	*********************************************************/
	typedef struct {
	U32 fastMode;
	U32 tableLog;
	} ZSTD_seqSymbol_header;

	typedef struct {
	U16 nextState;
	BYTE nbAdditionalBits;
	BYTE nbBits;
	U32 baseValue;
	} ZSTD_seqSymbol;

	#define SEQSYMBOL_TABLE_SIZE(log) (1 + (1 << (log)))

	typedef struct {
	ZSTD_seqSymbol LLTable[SEQSYMBOL_TABLE_SIZE(LLFSELog)]; /* Note : Space reserved for FSE Tables */
	ZSTD_seqSymbol OFTable[SEQSYMBOL_TABLE_SIZE(OffFSELog)]; /* is also used as temporary workspace while building hufTable during DDict creation */
	ZSTD_seqSymbol MLTable[SEQSYMBOL_TABLE_SIZE(MLFSELog)]; /* and therefore must be at least HUF_DECOMPRESS_WORKSPACE_SIZE large */
	HUF_DTable hufTable[HUF_DTABLE_SIZE(HufLog)]; /* can accommodate HUF_decompress4X */
	U32 rep[ZSTD_REP_NUM];
	} ZSTD_entropyDTables_t;

	typedef enum { ZSTDds_getFrameHeaderSize, ZSTDds_decodeFrameHeader,
	ZSTDds_decodeBlockHeader, ZSTDds_decompressBlock,
	ZSTDds_decompressLastBlock, ZSTDds_checkChecksum,
	ZSTDds_decodeSkippableHeader, ZSTDds_skipFrame } ZSTD_dStage;

	typedef enum { zdss_init=0, zdss_loadHeader,
	zdss_read, zdss_load, zdss_flush } ZSTD_dStreamStage;

	typedef enum {
	ZSTD_use_indefinitely = -1, /* Use the dictionary indefinitely */
	ZSTD_dont_use = 0, /* Do not use the dictionary (if one exists free it) */
	ZSTD_use_once = 1 /* Use the dictionary once and set to ZSTD_dont_use */
	} ZSTD_dictUses_e;

	typedef enum {
	ZSTD_obm_buffered = 0, /* Buffer the output */
	ZSTD_obm_stable = 1 /* ZSTD_outBuffer is stable */
	} ZSTD_outBufferMode_e;

	struct ZSTD_DCtx_s
	{
	const ZSTD_seqSymbol* LLTptr;
	const ZSTD_seqSymbol* MLTptr;
	const ZSTD_seqSymbol* OFTptr;
	const HUF_DTable* HUFptr;
	ZSTD_entropyDTables_t entropy;
	U32 workspace[HUF_DECOMPRESS_WORKSPACE_SIZE_U32]; /* space needed when building huffman tables */
	const void* previousDstEnd; /* detect continuity */
	const void* prefixStart; /* start of current segment */
	const void* virtualStart; /* virtual start of previous segment if it was just before current one */
	const void* dictEnd; /* end of previous segment */
	size_t expected;
	ZSTD_frameHeader fParams;
	U64 decodedSize;
	blockType_e bType; /* used in ZSTD_decompressContinue(), store blockType between block header decoding and block decompression stages */
	ZSTD_dStage stage;
	U32 litEntropy;
	U32 fseEntropy;
	XXH64_state_t xxhState;
	size_t headerSize;
	ZSTD_format_e format;
	const BYTE* litPtr;
	ZSTD_customMem customMem;
	size_t litSize;
	size_t rleSize;
	size_t staticSize;
	int bmi2; /* == 1 if the CPU supports BMI2 and 0 otherwise. CPU support is determined dynamically once per context lifetime. */

	/* dictionary */
	ZSTD_DDict* ddictLocal;
	const ZSTD_DDict* ddict; /* set by ZSTD_initDStream_usingDDict(), or ZSTD_DCtx_refDDict() */
	U32 dictID;
	int ddictIsCold; /* if == 1 : dictionary is "new" for working context, and presumed "cold" (not in cpu cache) */
	ZSTD_dictUses_e dictUses;

	/* streaming */
	ZSTD_dStreamStage streamStage;
	char* inBuff;
	size_t inBuffSize;
	size_t inPos;
	size_t maxWindowSize;
	char* outBuff;
	size_t outBuffSize;
	size_t outStart;
	size_t outEnd;
	size_t lhSize;
	void* legacyContext;
	U32 previousLegacyVersion;
	U32 legacyVersion;
	U32 hostageByte;
	int noForwardProgress;
	ZSTD_outBufferMode_e outBufferMode;
	ZSTD_outBuffer expectedOutBuffer;

	/* workspace */
	BYTE litBuffer[ZSTD_BLOCKSIZE_MAX + WILDCOPY_OVERLENGTH];
	BYTE headerBuffer[ZSTD_FRAMEHEADERSIZE_MAX];

	size_t oversizedDuration;

	#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
	void const* dictContentBeginForFuzzing;
	void const* dictContentEndForFuzzing;
	#endif
	}; /* typedef'd to ZSTD_DCtx within "zstd.h" */


	/-******************************************************
	* Shared internal functions
	*********************************************************/

	/*! ZSTD_loadDEntropy() :
	* dict : must point at beginning of a valid zstd dictionary.
	* @return : size of dictionary header (size of magic number + dict ID + entropy tables) */
	size_t ZSTD_loadDEntropy(ZSTD_entropyDTables_t* entropy,
	const void* const dict, size_t const dictSize);

	/*! ZSTD_checkContinuity() :
	* check if next `dst` follows previous position, where decompression ended.
	* If yes, do nothing (continue on current segment).
	* If not, classify previous segment as "external dictionary", and start a new segment.
	* This function cannot fail. */
	void ZSTD_checkContinuity(ZSTD_DCtx* dctx, const void* dst);


	#endif /* ZSTD_DECOMPRESS_INTERNAL_H */
	/** ended inlining zstd_decompress_internal.h **/
	/** start inlining zstd_ddict.h **/
	/*
	* Copyright (c) 2016-2020, Yann Collet, Facebook, Inc.
	* All rights reserved.
	*
	* This source code is licensed under both the BSD-style license (found in the
	* LICENSE file in the root directory of this source tree) and the GPLv2 (found
	* in the COPYING file in the root directory of this source tree).
	* You may select, at your option, one of the above-listed licenses.
	*/


	#ifndef ZSTD_DDICT_H
	#define ZSTD_DDICT_H

	/-******************************************************
	* Dependencies
	*********************************************************/
	#include <stddef.h> /* size_t */
	/** skipping file: ../zstd.h **/


	/-******************************************************
	* Interface
	*********************************************************/

	/* note: several prototypes are already published in `zstd.h` :
	* ZSTD_createDDict()
	* ZSTD_createDDict_byReference()
	* ZSTD_createDDict_advanced()
	* ZSTD_freeDDict()
	* ZSTD_initStaticDDict()
	* ZSTD_sizeof_DDict()
	* ZSTD_estimateDDictSize()
	* ZSTD_getDictID_fromDict()
	*/

	const void* ZSTD_DDict_dictContent(const ZSTD_DDict* ddict);
	size_t ZSTD_DDict_dictSize(const ZSTD_DDict* ddict);

	void ZSTD_copyDDictParameters(ZSTD_DCtx* dctx, const ZSTD_DDict* ddict);



	#endif /* ZSTD_DDICT_H */
	/** ended inlining zstd_ddict.h **/

	#if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT>=1)
	/** start inlining ../legacy/zstd_legacy.h **/
	/*
	* Copyright (c) 2016-2020, Yann Collet, Facebook, Inc.
	* All rights reserved.
	*
	* This source code is licensed under both the BSD-style license (found in the
	* LICENSE file in the root directory of this source tree) and the GPLv2 (found
	* in the COPYING file in the root directory of this source tree).
	* You may select, at your option, one of the above-listed licenses.
	*/

	#ifndef ZSTD_LEGACY_H
	#define ZSTD_LEGACY_H

	#if defined (__cplusplus)
	extern "C" {
	#endif

	/* *************************************
	* Includes
	***************************************/
	/** skipping file: ../common/mem.h **/
	/** skipping file: ../common/error_private.h **/
	/** skipping file: ../common/zstd_internal.h **/

	#if !defined (ZSTD_LEGACY_SUPPORT) \|\| (ZSTD_LEGACY_SUPPORT == 0)
	# undef ZSTD_LEGACY_SUPPORT
	# define ZSTD_LEGACY_SUPPORT 8
	#endif

	#if (ZSTD_LEGACY_SUPPORT <= 1)
	/** start inlining zstd_v01.h **/
	/*
	* Copyright (c) 2016-2020, Yann Collet, Facebook, Inc.
	* All rights reserved.
	*
	* This source code is licensed under both the BSD-style license (found in the
	* LICENSE file in the root directory of this source tree) and the GPLv2 (found
	* in the COPYING file in the root directory of this source tree).
	* You may select, at your option, one of the above-listed licenses.
	*/

	#ifndef ZSTD_V01_H_28739879432
	#define ZSTD_V01_H_28739879432

	#if defined (__cplusplus)
	extern "C" {
	#endif

	/* *************************************
	* Includes
	***************************************/
	#include <stddef.h> /* size_t */


	/* *************************************
	* Simple one-step function
	***************************************/
	/**
	ZSTDv01_decompress() : decompress ZSTD frames compliant with v0.1.x format
	compressedSize : is the exact source size
	maxOriginalSize : is the size of the 'dst' buffer, which must be already allocated.
	It must be equal or larger than originalSize, otherwise decompression will fail.
	return : the number of bytes decompressed into destination buffer (originalSize)
	or an errorCode if it fails (which can be tested using ZSTDv01_isError())
	*/
	size_t ZSTDv01_decompress( void* dst, size_t maxOriginalSize,
	const void* src, size_t compressedSize);

	/**
	ZSTDv01_findFrameSizeInfoLegacy() : get the source length and decompressed bound of a ZSTD frame compliant with v0.1.x format
	srcSize : The size of the 'src' buffer, at least as large as the frame pointed to by 'src'
	cSize (output parameter) : the number of bytes that would be read to decompress this frame
	or an error code if it fails (which can be tested using ZSTDv01_isError())
	dBound (output parameter) : an upper-bound for the decompressed size of the data in the frame
	or ZSTD_CONTENTSIZE_ERROR if an error occurs

	note : assumes `cSize` and `dBound` are _not_ NULL.
	*/
	void ZSTDv01_findFrameSizeInfoLegacy(const void *src, size_t srcSize,
	size_t* cSize, unsigned long long* dBound);

	/**
	ZSTDv01_isError() : tells if the result of ZSTDv01_decompress() is an error
	*/
	unsigned ZSTDv01_isError(size_t code);


	/* *************************************
	* Advanced functions
	***************************************/
	typedef struct ZSTDv01_Dctx_s ZSTDv01_Dctx;
	ZSTDv01_Dctx* ZSTDv01_createDCtx(void);
	size_t ZSTDv01_freeDCtx(ZSTDv01_Dctx* dctx);

	size_t ZSTDv01_decompressDCtx(void* ctx,
	void* dst, size_t maxOriginalSize,
	const void* src, size_t compressedSize);

	/* *************************************
	* Streaming functions
	***************************************/
	size_t ZSTDv01_resetDCtx(ZSTDv01_Dctx* dctx);

	size_t ZSTDv01_nextSrcSizeToDecompress(ZSTDv01_Dctx* dctx);
	size_t ZSTDv01_decompressContinue(ZSTDv01_Dctx* dctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize);
	/**
	Use above functions alternatively.
	ZSTD_nextSrcSizeToDecompress() tells how much bytes to provide as 'srcSize' to ZSTD_decompressContinue().
	ZSTD_decompressContinue() will use previous data blocks to improve compression if they are located prior to current block.
	Result is the number of bytes regenerated within 'dst'.
	It can be zero, which is not an error; it just means ZSTD_decompressContinue() has decoded some header.
	*/

	/* *************************************
	* Prefix - version detection
	***************************************/
	#define ZSTDv01_magicNumber 0xFD2FB51E /* Big Endian version */
	#define ZSTDv01_magicNumberLE 0x1EB52FFD /* Little Endian version */


	#if defined (__cplusplus)
	}
	#endif

	#endif /* ZSTD_V01_H_28739879432 */
	/** ended inlining zstd_v01.h **/
	#endif
	#if (ZSTD_LEGACY_SUPPORT <= 2)
	/** start inlining zstd_v02.h **/
	/*
	* Copyright (c) 2016-2020, Yann Collet, Facebook, Inc.
	* All rights reserved.
	*
	* This source code is licensed under both the BSD-style license (found in the
	* LICENSE file in the root directory of this source tree) and the GPLv2 (found
	* in the COPYING file in the root directory of this source tree).
	* You may select, at your option, one of the above-listed licenses.
	*/

	#ifndef ZSTD_V02_H_4174539423
	#define ZSTD_V02_H_4174539423

	#if defined (__cplusplus)
	extern "C" {
	#endif

	/* *************************************
	* Includes
	***************************************/
	#include <stddef.h> /* size_t */


	/* *************************************
	* Simple one-step function
	***************************************/
	/**
	ZSTDv02_decompress() : decompress ZSTD frames compliant with v0.2.x format
	compressedSize : is the exact source size
	maxOriginalSize : is the size of the 'dst' buffer, which must be already allocated.
	It must be equal or larger than originalSize, otherwise decompression will fail.
	return : the number of bytes decompressed into destination buffer (originalSize)
	or an errorCode if it fails (which can be tested using ZSTDv01_isError())
	*/
	size_t ZSTDv02_decompress( void* dst, size_t maxOriginalSize,
	const void* src, size_t compressedSize);

	/**
	ZSTDv02_findFrameSizeInfoLegacy() : get the source length and decompressed bound of a ZSTD frame compliant with v0.2.x format
	srcSize : The size of the 'src' buffer, at least as large as the frame pointed to by 'src'
	cSize (output parameter) : the number of bytes that would be read to decompress this frame
	or an error code if it fails (which can be tested using ZSTDv01_isError())
	dBound (output parameter) : an upper-bound for the decompressed size of the data in the frame
	or ZSTD_CONTENTSIZE_ERROR if an error occurs

	note : assumes `cSize` and `dBound` are _not_ NULL.
	*/
	void ZSTDv02_findFrameSizeInfoLegacy(const void *src, size_t srcSize,
	size_t* cSize, unsigned long long* dBound);

	/**
	ZSTDv02_isError() : tells if the result of ZSTDv02_decompress() is an error
	*/
	unsigned ZSTDv02_isError(size_t code);


	/* *************************************
	* Advanced functions
	***************************************/
	typedef struct ZSTDv02_Dctx_s ZSTDv02_Dctx;
	ZSTDv02_Dctx* ZSTDv02_createDCtx(void);
	size_t ZSTDv02_freeDCtx(ZSTDv02_Dctx* dctx);

	size_t ZSTDv02_decompressDCtx(void* ctx,
	void* dst, size_t maxOriginalSize,
	const void* src, size_t compressedSize);

	/* *************************************
	* Streaming functions
	***************************************/
	size_t ZSTDv02_resetDCtx(ZSTDv02_Dctx* dctx);

	size_t ZSTDv02_nextSrcSizeToDecompress(ZSTDv02_Dctx* dctx);
	size_t ZSTDv02_decompressContinue(ZSTDv02_Dctx* dctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize);
	/**
	Use above functions alternatively.
	ZSTD_nextSrcSizeToDecompress() tells how much bytes to provide as 'srcSize' to ZSTD_decompressContinue().
	ZSTD_decompressContinue() will use previous data blocks to improve compression if they are located prior to current block.
	Result is the number of bytes regenerated within 'dst'.
	It can be zero, which is not an error; it just means ZSTD_decompressContinue() has decoded some header.
	*/

	/* *************************************
	* Prefix - version detection
	***************************************/
	#define ZSTDv02_magicNumber 0xFD2FB522 /* v0.2 */


	#if defined (__cplusplus)
	}
	#endif

	#endif /* ZSTD_V02_H_4174539423 */
	/** ended inlining zstd_v02.h **/
	#endif
	#if (ZSTD_LEGACY_SUPPORT <= 3)
	/** start inlining zstd_v03.h **/
	/*
	* Copyright (c) 2016-2020, Yann Collet, Facebook, Inc.
	* All rights reserved.
	*
	* This source code is licensed under both the BSD-style license (found in the
	* LICENSE file in the root directory of this source tree) and the GPLv2 (found
	* in the COPYING file in the root directory of this source tree).
	* You may select, at your option, one of the above-listed licenses.
	*/

	#ifndef ZSTD_V03_H_298734209782
	#define ZSTD_V03_H_298734209782

	#if defined (__cplusplus)
	extern "C" {
	#endif

	/* *************************************
	* Includes
	***************************************/
	#include <stddef.h> /* size_t */


	/* *************************************
	* Simple one-step function
	***************************************/
	/**
	ZSTDv03_decompress() : decompress ZSTD frames compliant with v0.3.x format
	compressedSize : is the exact source size
	maxOriginalSize : is the size of the 'dst' buffer, which must be already allocated.
	It must be equal or larger than originalSize, otherwise decompression will fail.
	return : the number of bytes decompressed into destination buffer (originalSize)
	or an errorCode if it fails (which can be tested using ZSTDv01_isError())
	*/
	size_t ZSTDv03_decompress( void* dst, size_t maxOriginalSize,
	const void* src, size_t compressedSize);

	/**
	ZSTDv03_findFrameSizeInfoLegacy() : get the source length and decompressed bound of a ZSTD frame compliant with v0.3.x format
	srcSize : The size of the 'src' buffer, at least as large as the frame pointed to by 'src'
	cSize (output parameter) : the number of bytes that would be read to decompress this frame
	or an error code if it fails (which can be tested using ZSTDv01_isError())
	dBound (output parameter) : an upper-bound for the decompressed size of the data in the frame
	or ZSTD_CONTENTSIZE_ERROR if an error occurs

	note : assumes `cSize` and `dBound` are _not_ NULL.
	*/
	void ZSTDv03_findFrameSizeInfoLegacy(const void *src, size_t srcSize,
	size_t* cSize, unsigned long long* dBound);

	/**
	ZSTDv03_isError() : tells if the result of ZSTDv03_decompress() is an error
	*/
	unsigned ZSTDv03_isError(size_t code);


	/* *************************************
	* Advanced functions
	***************************************/
	typedef struct ZSTDv03_Dctx_s ZSTDv03_Dctx;
	ZSTDv03_Dctx* ZSTDv03_createDCtx(void);
	size_t ZSTDv03_freeDCtx(ZSTDv03_Dctx* dctx);

	size_t ZSTDv03_decompressDCtx(void* ctx,
	void* dst, size_t maxOriginalSize,
	const void* src, size_t compressedSize);

	/* *************************************
	* Streaming functions
	***************************************/
	size_t ZSTDv03_resetDCtx(ZSTDv03_Dctx* dctx);

	size_t ZSTDv03_nextSrcSizeToDecompress(ZSTDv03_Dctx* dctx);
	size_t ZSTDv03_decompressContinue(ZSTDv03_Dctx* dctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize);
	/**
	Use above functions alternatively.
	ZSTD_nextSrcSizeToDecompress() tells how much bytes to provide as 'srcSize' to ZSTD_decompressContinue().
	ZSTD_decompressContinue() will use previous data blocks to improve compression if they are located prior to current block.
	Result is the number of bytes regenerated within 'dst'.
	It can be zero, which is not an error; it just means ZSTD_decompressContinue() has decoded some header.
	*/

	/* *************************************
	* Prefix - version detection
	***************************************/
	#define ZSTDv03_magicNumber 0xFD2FB523 /* v0.3 */


	#if defined (__cplusplus)
	}
	#endif

	#endif /* ZSTD_V03_H_298734209782 */
	/** ended inlining zstd_v03.h **/
	#endif
	#if (ZSTD_LEGACY_SUPPORT <= 4)
	/** start inlining zstd_v04.h **/
	/*
	* Copyright (c) 2016-2020, Yann Collet, Facebook, Inc.
	* All rights reserved.
	*
	* This source code is licensed under both the BSD-style license (found in the
	* LICENSE file in the root directory of this source tree) and the GPLv2 (found
	* in the COPYING file in the root directory of this source tree).
	* You may select, at your option, one of the above-listed licenses.
	*/

	#ifndef ZSTD_V04_H_91868324769238
	#define ZSTD_V04_H_91868324769238

	#if defined (__cplusplus)
	extern "C" {
	#endif

	/* *************************************
	* Includes
	***************************************/
	#include <stddef.h> /* size_t */


	/* *************************************
	* Simple one-step function
	***************************************/
	/**
	ZSTDv04_decompress() : decompress ZSTD frames compliant with v0.4.x format
	compressedSize : is the exact source size
	maxOriginalSize : is the size of the 'dst' buffer, which must be already allocated.
	It must be equal or larger than originalSize, otherwise decompression will fail.
	return : the number of bytes decompressed into destination buffer (originalSize)
	or an errorCode if it fails (which can be tested using ZSTDv01_isError())
	*/
	size_t ZSTDv04_decompress( void* dst, size_t maxOriginalSize,
	const void* src, size_t compressedSize);

	/**
	ZSTDv04_findFrameSizeInfoLegacy() : get the source length and decompressed bound of a ZSTD frame compliant with v0.4.x format
	srcSize : The size of the 'src' buffer, at least as large as the frame pointed to by 'src'
	cSize (output parameter) : the number of bytes that would be read to decompress this frame
	or an error code if it fails (which can be tested using ZSTDv01_isError())
	dBound (output parameter) : an upper-bound for the decompressed size of the data in the frame
	or ZSTD_CONTENTSIZE_ERROR if an error occurs

	note : assumes `cSize` and `dBound` are _not_ NULL.
	*/
	void ZSTDv04_findFrameSizeInfoLegacy(const void *src, size_t srcSize,
	size_t* cSize, unsigned long long* dBound);

	/**
	ZSTDv04_isError() : tells if the result of ZSTDv04_decompress() is an error
	*/
	unsigned ZSTDv04_isError(size_t code);


	/* *************************************
	* Advanced functions
	***************************************/
	typedef struct ZSTDv04_Dctx_s ZSTDv04_Dctx;
	ZSTDv04_Dctx* ZSTDv04_createDCtx(void);
	size_t ZSTDv04_freeDCtx(ZSTDv04_Dctx* dctx);

	size_t ZSTDv04_decompressDCtx(ZSTDv04_Dctx* dctx,
	void* dst, size_t maxOriginalSize,
	const void* src, size_t compressedSize);


	/* *************************************
	* Direct Streaming
	***************************************/
	size_t ZSTDv04_resetDCtx(ZSTDv04_Dctx* dctx);

	size_t ZSTDv04_nextSrcSizeToDecompress(ZSTDv04_Dctx* dctx);
	size_t ZSTDv04_decompressContinue(ZSTDv04_Dctx* dctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize);
	/**
	Use above functions alternatively.
	ZSTD_nextSrcSizeToDecompress() tells how much bytes to provide as 'srcSize' to ZSTD_decompressContinue().
	ZSTD_decompressContinue() will use previous data blocks to improve compression if they are located prior to current block.
	Result is the number of bytes regenerated within 'dst'.
	It can be zero, which is not an error; it just means ZSTD_decompressContinue() has decoded some header.
	*/


	/* *************************************
	* Buffered Streaming
	***************************************/
	typedef struct ZBUFFv04_DCtx_s ZBUFFv04_DCtx;
	ZBUFFv04_DCtx* ZBUFFv04_createDCtx(void);
	size_t ZBUFFv04_freeDCtx(ZBUFFv04_DCtx* dctx);

	size_t ZBUFFv04_decompressInit(ZBUFFv04_DCtx* dctx);
	size_t ZBUFFv04_decompressWithDictionary(ZBUFFv04_DCtx* dctx, const void* dict, size_t dictSize);

	size_t ZBUFFv04_decompressContinue(ZBUFFv04_DCtx* dctx, void* dst, size_t* maxDstSizePtr, const void* src, size_t* srcSizePtr);

	/ **********************************************
	* Streaming decompression
	*
	* A ZBUFF_DCtx object is required to track streaming operation.
	* Use ZBUFF_createDCtx() and ZBUFF_freeDCtx() to create/release resources.
	* Use ZBUFF_decompressInit() to start a new decompression operation.
	* ZBUFF_DCtx objects can be reused multiple times.
	*
	* Optionally, a reference to a static dictionary can be set, using ZBUFF_decompressWithDictionary()
	* It must be the same content as the one set during compression phase.
	* Dictionary content must remain accessible during the decompression process.
	*
	* Use ZBUFF_decompressContinue() repetitively to consume your input.
	* srcSizePtr and maxDstSizePtr can be any size.
	* The function will report how many bytes were read or written by modifying srcSizePtr and maxDstSizePtr.
	* Note that it may not consume the entire input, in which case it's up to the caller to present remaining input again.
	* The content of dst will be overwritten (up to *maxDstSizePtr) at each function call, so save its content if it matters or change dst.
	* @return : a hint to preferred nb of bytes to use as input for next function call (it's only a hint, to improve latency)
	* or 0 when a frame is completely decoded
	* or an error code, which can be tested using ZBUFF_isError().
	*
	* Hint : recommended buffer sizes (not compulsory) : ZBUFF_recommendedDInSize / ZBUFF_recommendedDOutSize
	* output : ZBUFF_recommendedDOutSize==128 KB block size is the internal unit, it ensures it's always possible to write a full block when it's decoded.
	* input : ZBUFF_recommendedDInSize==128Kb+3; just follow indications from ZBUFF_decompressContinue() to minimize latency. It should always be <= 128 KB + 3 .
	* **************************************************/
	unsigned ZBUFFv04_isError(size_t errorCode);
	const char* ZBUFFv04_getErrorName(size_t errorCode);


	/** The below functions provide recommended buffer sizes for Compression or Decompression operations.
	* These sizes are not compulsory, they just tend to offer better latency */
	size_t ZBUFFv04_recommendedDInSize(void);
	size_t ZBUFFv04_recommendedDOutSize(void);


	/* *************************************
	* Prefix - version detection
	***************************************/
	#define ZSTDv04_magicNumber 0xFD2FB524 /* v0.4 */


	#if defined (__cplusplus)
	}
	#endif

	#endif /* ZSTD_V04_H_91868324769238 */
	/** ended inlining zstd_v04.h **/
	#endif
	#if (ZSTD_LEGACY_SUPPORT <= 5)
	/** start inlining zstd_v05.h **/
	/*
	* Copyright (c) 2016-2020, Yann Collet, Facebook, Inc.
	* All rights reserved.
	*
	* This source code is licensed under both the BSD-style license (found in the
	* LICENSE file in the root directory of this source tree) and the GPLv2 (found
	* in the COPYING file in the root directory of this source tree).
	* You may select, at your option, one of the above-listed licenses.
	*/

	#ifndef ZSTDv05_H
	#define ZSTDv05_H

	#if defined (__cplusplus)
	extern "C" {
	#endif

	/-************************************
	* Dependencies
	***************************************/
	#include <stddef.h> /* size_t */
	/** skipping file: ../common/mem.h **/


	/* *************************************
	* Simple functions
	***************************************/
	/*! ZSTDv05_decompress() :
	`compressedSize` : is the _exact_ size of the compressed blob, otherwise decompression will fail.
	`dstCapacity` must be large enough, equal or larger than originalSize.
	@return : the number of bytes decompressed into `dst` (<= `dstCapacity`),
	or an errorCode if it fails (which can be tested using ZSTDv05_isError()) */
	size_t ZSTDv05_decompress( void* dst, size_t dstCapacity,
	const void* src, size_t compressedSize);

	/**
	ZSTDv05_findFrameSizeInfoLegacy() : get the source length and decompressed bound of a ZSTD frame compliant with v0.5.x format
	srcSize : The size of the 'src' buffer, at least as large as the frame pointed to by 'src'
	cSize (output parameter) : the number of bytes that would be read to decompress this frame
	or an error code if it fails (which can be tested using ZSTDv01_isError())
	dBound (output parameter) : an upper-bound for the decompressed size of the data in the frame
	or ZSTD_CONTENTSIZE_ERROR if an error occurs

	note : assumes `cSize` and `dBound` are _not_ NULL.
	*/
	void ZSTDv05_findFrameSizeInfoLegacy(const void *src, size_t srcSize,
	size_t* cSize, unsigned long long* dBound);

	/* *************************************
	* Helper functions
	***************************************/
	/* Error Management */
	unsigned ZSTDv05_isError(size_t code); /!< tells if a `size_t` function result is an error code /
	const char* ZSTDv05_getErrorName(size_t code); /!< provides readable string for an error code /


	/* *************************************
	* Explicit memory management
	***************************************/
	/** Decompression context */
	typedef struct ZSTDv05_DCtx_s ZSTDv05_DCtx;
	ZSTDv05_DCtx* ZSTDv05_createDCtx(void);
	size_t ZSTDv05_freeDCtx(ZSTDv05_DCtx* dctx); /!< @return : errorCode /

	/** ZSTDv05_decompressDCtx() :
	* Same as ZSTDv05_decompress(), but requires an already allocated ZSTDv05_DCtx (see ZSTDv05_createDCtx()) */
	size_t ZSTDv05_decompressDCtx(ZSTDv05_DCtx* ctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);


	/-**********************
	* Simple Dictionary API
	*************************/
	/*! ZSTDv05_decompress_usingDict() :
	* Decompression using a pre-defined Dictionary content (see dictBuilder).
	* Dictionary must be identical to the one used during compression, otherwise regenerated data will be corrupted.
	* Note : dict can be NULL, in which case, it's equivalent to ZSTDv05_decompressDCtx() */
	size_t ZSTDv05_decompress_usingDict(ZSTDv05_DCtx* dctx,
	void* dst, size_t dstCapacity,
	const void* src, size_t srcSize,
	const void* dict,size_t dictSize);

	/-***********************
	* Advanced Streaming API
	***************************/
	typedef enum { ZSTDv05_fast, ZSTDv05_greedy, ZSTDv05_lazy, ZSTDv05_lazy2, ZSTDv05_btlazy2, ZSTDv05_opt, ZSTDv05_btopt } ZSTDv05_strategy;
	typedef struct {
	U64 srcSize;
	U32 windowLog; /* the only useful information to retrieve */
	U32 contentLog; U32 hashLog; U32 searchLog; U32 searchLength; U32 targetLength; ZSTDv05_strategy strategy;
	} ZSTDv05_parameters;
	size_t ZSTDv05_getFrameParams(ZSTDv05_parameters* params, const void* src, size_t srcSize);

	size_t ZSTDv05_decompressBegin_usingDict(ZSTDv05_DCtx* dctx, const void* dict, size_t dictSize);
	void ZSTDv05_copyDCtx(ZSTDv05_DCtx* dstDCtx, const ZSTDv05_DCtx* srcDCtx);
	size_t ZSTDv05_nextSrcSizeToDecompress(ZSTDv05_DCtx* dctx);
	size_t ZSTDv05_decompressContinue(ZSTDv05_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);


	/-**********************
	* ZBUFF API
	*************************/
	typedef struct ZBUFFv05_DCtx_s ZBUFFv05_DCtx;
	ZBUFFv05_DCtx* ZBUFFv05_createDCtx(void);
	size_t ZBUFFv05_freeDCtx(ZBUFFv05_DCtx* dctx);

	size_t ZBUFFv05_decompressInit(ZBUFFv05_DCtx* dctx);
	size_t ZBUFFv05_decompressInitDictionary(ZBUFFv05_DCtx* dctx, const void* dict, size_t dictSize);

	size_t ZBUFFv05_decompressContinue(ZBUFFv05_DCtx* dctx,
	void* dst, size_t* dstCapacityPtr,
	const void* src, size_t* srcSizePtr);

	/-**************************************************************************
	* Streaming decompression
	*
	* A ZBUFFv05_DCtx object is required to track streaming operations.
	* Use ZBUFFv05_createDCtx() and ZBUFFv05_freeDCtx() to create/release resources.
	* Use ZBUFFv05_decompressInit() to start a new decompression operation,
	* or ZBUFFv05_decompressInitDictionary() if decompression requires a dictionary.
	* Note that ZBUFFv05_DCtx objects can be reused multiple times.
	*
	* Use ZBUFFv05_decompressContinue() repetitively to consume your input.
	* srcSizePtr and dstCapacityPtr can be any size.
	* The function will report how many bytes were read or written by modifying srcSizePtr and dstCapacityPtr.
	* Note that it may not consume the entire input, in which case it's up to the caller to present remaining input again.
	* The content of @dst will be overwritten (up to *dstCapacityPtr) at each function call, so save its content if it matters or change @dst.
	* @return : a hint to preferred nb of bytes to use as input for next function call (it's only a hint, to help latency)
	* or 0 when a frame is completely decoded
	* or an error code, which can be tested using ZBUFFv05_isError().
	*
	* Hint : recommended buffer sizes (not compulsory) : ZBUFFv05_recommendedDInSize() / ZBUFFv05_recommendedDOutSize()
	* output : ZBUFFv05_recommendedDOutSize==128 KB block size is the internal unit, it ensures it's always possible to write a full block when decoded.
	* input : ZBUFFv05_recommendedDInSize==128Kb+3; just follow indications from ZBUFFv05_decompressContinue() to minimize latency. It should always be <= 128 KB + 3 .
	* *******************************************************************************/


	/* *************************************
	* Tool functions
	***************************************/
	unsigned ZBUFFv05_isError(size_t errorCode);
	const char* ZBUFFv05_getErrorName(size_t errorCode);

	/** Functions below provide recommended buffer sizes for Compression or Decompression operations.
	* These sizes are just hints, and tend to offer better latency */
	size_t ZBUFFv05_recommendedDInSize(void);
	size_t ZBUFFv05_recommendedDOutSize(void);



	/-************************************
	* Constants
	***************************************/
	#define ZSTDv05_MAGICNUMBER 0xFD2FB525 /* v0.5 */




	#if defined (__cplusplus)
	}
	#endif

	#endif /* ZSTDv0505_H */
	/** ended inlining zstd_v05.h **/
	#endif
	#if (ZSTD_LEGACY_SUPPORT <= 6)
	/** start inlining zstd_v06.h **/
	/*
	* Copyright (c) 2016-2020, Yann Collet, Facebook, Inc.
	* All rights reserved.
	*
	* This source code is licensed under both the BSD-style license (found in the
	* LICENSE file in the root directory of this source tree) and the GPLv2 (found
	* in the COPYING file in the root directory of this source tree).
	* You may select, at your option, one of the above-listed licenses.
	*/

	#ifndef ZSTDv06_H
	#define ZSTDv06_H

	#if defined (__cplusplus)
	extern "C" {
	#endif

	/====== Dependency ======/
	#include <stddef.h> /* size_t */


	/====== Export for Windows ======/
	/*!
	* ZSTDv06_DLL_EXPORT :
	* Enable exporting of functions when building a Windows DLL
	*/
	#if defined(_WIN32) && defined(ZSTDv06_DLL_EXPORT) && (ZSTDv06_DLL_EXPORT==1)
	# define ZSTDLIBv06_API __declspec(dllexport)
	#else
	# define ZSTDLIBv06_API
	#endif


	/* *************************************
	* Simple functions
	***************************************/
	/*! ZSTDv06_decompress() :
	`compressedSize` : is the _exact_ size of the compressed blob, otherwise decompression will fail.
	`dstCapacity` must be large enough, equal or larger than originalSize.
	@return : the number of bytes decompressed into `dst` (<= `dstCapacity`),
	or an errorCode if it fails (which can be tested using ZSTDv06_isError()) */
	ZSTDLIBv06_API size_t ZSTDv06_decompress( void* dst, size_t dstCapacity,
	const void* src, size_t compressedSize);

	/**
	ZSTDv06_findFrameSizeInfoLegacy() : get the source length and decompressed bound of a ZSTD frame compliant with v0.6.x format
	srcSize : The size of the 'src' buffer, at least as large as the frame pointed to by 'src'
	cSize (output parameter) : the number of bytes that would be read to decompress this frame
	or an error code if it fails (which can be tested using ZSTDv01_isError())
	dBound (output parameter) : an upper-bound for the decompressed size of the data in the frame
	or ZSTD_CONTENTSIZE_ERROR if an error occurs

	note : assumes `cSize` and `dBound` are _not_ NULL.
	*/
	void ZSTDv06_findFrameSizeInfoLegacy(const void *src, size_t srcSize,
	size_t* cSize, unsigned long long* dBound);

	/* *************************************
	* Helper functions
	***************************************/
	ZSTDLIBv06_API size_t ZSTDv06_compressBound(size_t srcSize); /!< maximum compressed size (worst case scenario) /

	/* Error Management */
	ZSTDLIBv06_API unsigned ZSTDv06_isError(size_t code); /!< tells if a `size_t` function result is an error code /
	ZSTDLIBv06_API const char* ZSTDv06_getErrorName(size_t code); /!< provides readable string for an error code /


	/* *************************************
	* Explicit memory management
	***************************************/
	/** Decompression context */
	typedef struct ZSTDv06_DCtx_s ZSTDv06_DCtx;
	ZSTDLIBv06_API ZSTDv06_DCtx* ZSTDv06_createDCtx(void);
	ZSTDLIBv06_API size_t ZSTDv06_freeDCtx(ZSTDv06_DCtx* dctx); /!< @return : errorCode /

	/** ZSTDv06_decompressDCtx() :
	* Same as ZSTDv06_decompress(), but requires an already allocated ZSTDv06_DCtx (see ZSTDv06_createDCtx()) */
	ZSTDLIBv06_API size_t ZSTDv06_decompressDCtx(ZSTDv06_DCtx* ctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);


	/-**********************
	* Dictionary API
	*************************/
	/*! ZSTDv06_decompress_usingDict() :
	* Decompression using a pre-defined Dictionary content (see dictBuilder).
	* Dictionary must be identical to the one used during compression, otherwise regenerated data will be corrupted.
	* Note : dict can be NULL, in which case, it's equivalent to ZSTDv06_decompressDCtx() */
	ZSTDLIBv06_API size_t ZSTDv06_decompress_usingDict(ZSTDv06_DCtx* dctx,
	void* dst, size_t dstCapacity,
	const void* src, size_t srcSize,
	const void* dict,size_t dictSize);


	/-***********************
	* Advanced Streaming API
	***************************/
	struct ZSTDv06_frameParams_s { unsigned long long frameContentSize; unsigned windowLog; };
	typedef struct ZSTDv06_frameParams_s ZSTDv06_frameParams;

	ZSTDLIBv06_API size_t ZSTDv06_getFrameParams(ZSTDv06_frameParams* fparamsPtr, const void* src, size_t srcSize); /*< doesn't consume input /
	ZSTDLIBv06_API size_t ZSTDv06_decompressBegin_usingDict(ZSTDv06_DCtx* dctx, const void* dict, size_t dictSize);
	ZSTDLIBv06_API void ZSTDv06_copyDCtx(ZSTDv06_DCtx* dctx, const ZSTDv06_DCtx* preparedDCtx);

	ZSTDLIBv06_API size_t ZSTDv06_nextSrcSizeToDecompress(ZSTDv06_DCtx* dctx);
	ZSTDLIBv06_API size_t ZSTDv06_decompressContinue(ZSTDv06_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);



	/* *************************************
	* ZBUFF API
	***************************************/

	typedef struct ZBUFFv06_DCtx_s ZBUFFv06_DCtx;
	ZSTDLIBv06_API ZBUFFv06_DCtx* ZBUFFv06_createDCtx(void);
	ZSTDLIBv06_API size_t ZBUFFv06_freeDCtx(ZBUFFv06_DCtx* dctx);

	ZSTDLIBv06_API size_t ZBUFFv06_decompressInit(ZBUFFv06_DCtx* dctx);
	ZSTDLIBv06_API size_t ZBUFFv06_decompressInitDictionary(ZBUFFv06_DCtx* dctx, const void* dict, size_t dictSize);

	ZSTDLIBv06_API size_t ZBUFFv06_decompressContinue(ZBUFFv06_DCtx* dctx,
	void* dst, size_t* dstCapacityPtr,
	const void* src, size_t* srcSizePtr);

	/-**************************************************************************
	* Streaming decompression howto
	*
	* A ZBUFFv06_DCtx object is required to track streaming operations.
	* Use ZBUFFv06_createDCtx() and ZBUFFv06_freeDCtx() to create/release resources.
	* Use ZBUFFv06_decompressInit() to start a new decompression operation,
	* or ZBUFFv06_decompressInitDictionary() if decompression requires a dictionary.
	* Note that ZBUFFv06_DCtx objects can be re-init multiple times.
	*
	* Use ZBUFFv06_decompressContinue() repetitively to consume your input.
	* srcSizePtr and dstCapacityPtr can be any size.
	* The function will report how many bytes were read or written by modifying srcSizePtr and dstCapacityPtr.
	* Note that it may not consume the entire input, in which case it's up to the caller to present remaining input again.
	* The content of `dst` will be overwritten (up to *dstCapacityPtr) at each function call, so save its content if it matters, or change `dst`.
	* @return : a hint to preferred nb of bytes to use as input for next function call (it's only a hint, to help latency),
	* or 0 when a frame is completely decoded,
	* or an error code, which can be tested using ZBUFFv06_isError().
	*
	* Hint : recommended buffer sizes (not compulsory) : ZBUFFv06_recommendedDInSize() and ZBUFFv06_recommendedDOutSize()
	* output : ZBUFFv06_recommendedDOutSize== 128 KB block size is the internal unit, it ensures it's always possible to write a full block when decoded.
	* input : ZBUFFv06_recommendedDInSize == 128KB + 3;
	* just follow indications from ZBUFFv06_decompressContinue() to minimize latency. It should always be <= 128 KB + 3 .
	* *******************************************************************************/


	/* *************************************
	* Tool functions
	***************************************/
	ZSTDLIBv06_API unsigned ZBUFFv06_isError(size_t errorCode);
	ZSTDLIBv06_API const char* ZBUFFv06_getErrorName(size_t errorCode);

	/** Functions below provide recommended buffer sizes for Compression or Decompression operations.
	* These sizes are just hints, they tend to offer better latency */
	ZSTDLIBv06_API size_t ZBUFFv06_recommendedDInSize(void);
	ZSTDLIBv06_API size_t ZBUFFv06_recommendedDOutSize(void);


	/-************************************
	* Constants
	***************************************/
	#define ZSTDv06_MAGICNUMBER 0xFD2FB526 /* v0.6 */



	#if defined (__cplusplus)
	}
	#endif

	#endif /* ZSTDv06_BUFFERED_H */
	/** ended inlining zstd_v06.h **/
	#endif
	#if (ZSTD_LEGACY_SUPPORT <= 7)
	/** start inlining zstd_v07.h **/
	/*
	* Copyright (c) 2016-2020, Yann Collet, Facebook, Inc.
	* All rights reserved.
	*
	* This source code is licensed under both the BSD-style license (found in the
	* LICENSE file in the root directory of this source tree) and the GPLv2 (found
	* in the COPYING file in the root directory of this source tree).
	* You may select, at your option, one of the above-listed licenses.
	*/

	#ifndef ZSTDv07_H_235446
	#define ZSTDv07_H_235446

	#if defined (__cplusplus)
	extern "C" {
	#endif

	/====== Dependency ======/
	#include <stddef.h> /* size_t */


	/====== Export for Windows ======/
	/*!
	* ZSTDv07_DLL_EXPORT :
	* Enable exporting of functions when building a Windows DLL
	*/
	#if defined(_WIN32) && defined(ZSTDv07_DLL_EXPORT) && (ZSTDv07_DLL_EXPORT==1)
	# define ZSTDLIBv07_API __declspec(dllexport)
	#else
	# define ZSTDLIBv07_API
	#endif


	/* *************************************
	* Simple API
	***************************************/
	/*! ZSTDv07_getDecompressedSize() :
	* @return : decompressed size if known, 0 otherwise.
	note 1 : if `0`, follow up with ZSTDv07_getFrameParams() to know precise failure cause.
	note 2 : decompressed size could be wrong or intentionally modified !
	always ensure results fit within application's authorized limits */
	unsigned long long ZSTDv07_getDecompressedSize(const void* src, size_t srcSize);

	/*! ZSTDv07_decompress() :
	`compressedSize` : must be _exact_ size of compressed input, otherwise decompression will fail.
	`dstCapacity` must be equal or larger than originalSize.
	@return : the number of bytes decompressed into `dst` (<= `dstCapacity`),
	or an errorCode if it fails (which can be tested using ZSTDv07_isError()) */
	ZSTDLIBv07_API size_t ZSTDv07_decompress( void* dst, size_t dstCapacity,
	const void* src, size_t compressedSize);

	/**
	ZSTDv07_findFrameSizeInfoLegacy() : get the source length and decompressed bound of a ZSTD frame compliant with v0.7.x format
	srcSize : The size of the 'src' buffer, at least as large as the frame pointed to by 'src'
	cSize (output parameter) : the number of bytes that would be read to decompress this frame
	or an error code if it fails (which can be tested using ZSTDv01_isError())
	dBound (output parameter) : an upper-bound for the decompressed size of the data in the frame
	or ZSTD_CONTENTSIZE_ERROR if an error occurs

	note : assumes `cSize` and `dBound` are _not_ NULL.
	*/
	void ZSTDv07_findFrameSizeInfoLegacy(const void *src, size_t srcSize,
	size_t* cSize, unsigned long long* dBound);

	/====== Helper functions ======/
	ZSTDLIBv07_API unsigned ZSTDv07_isError(size_t code); /!< tells if a `size_t` function result is an error code /
	ZSTDLIBv07_API const char* ZSTDv07_getErrorName(size_t code); /!< provides readable string from an error code /


	/-************************************
	* Explicit memory management
	***************************************/
	/** Decompression context */
	typedef struct ZSTDv07_DCtx_s ZSTDv07_DCtx;
	ZSTDLIBv07_API ZSTDv07_DCtx* ZSTDv07_createDCtx(void);
	ZSTDLIBv07_API size_t ZSTDv07_freeDCtx(ZSTDv07_DCtx* dctx); /!< @return : errorCode /

	/** ZSTDv07_decompressDCtx() :
	* Same as ZSTDv07_decompress(), requires an allocated ZSTDv07_DCtx (see ZSTDv07_createDCtx()) */
	ZSTDLIBv07_API size_t ZSTDv07_decompressDCtx(ZSTDv07_DCtx* ctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);


	/-***********************
	* Simple dictionary API
	***************************/
	/*! ZSTDv07_decompress_usingDict() :
	* Decompression using a pre-defined Dictionary content (see dictBuilder).
	* Dictionary must be identical to the one used during compression.
	* Note : This function load the dictionary, resulting in a significant startup time */
	ZSTDLIBv07_API size_t ZSTDv07_decompress_usingDict(ZSTDv07_DCtx* dctx,
	void* dst, size_t dstCapacity,
	const void* src, size_t srcSize,
	const void* dict,size_t dictSize);


	/-*************************
	* Advanced Dictionary API
	****************************/
	/*! ZSTDv07_createDDict() :
	* Create a digested dictionary, ready to start decompression operation without startup delay.
	* `dict` can be released after creation */
	typedef struct ZSTDv07_DDict_s ZSTDv07_DDict;
	ZSTDLIBv07_API ZSTDv07_DDict* ZSTDv07_createDDict(const void* dict, size_t dictSize);
	ZSTDLIBv07_API size_t ZSTDv07_freeDDict(ZSTDv07_DDict* ddict);

	/*! ZSTDv07_decompress_usingDDict() :
	* Decompression using a pre-digested Dictionary
	* Faster startup than ZSTDv07_decompress_usingDict(), recommended when same dictionary is used multiple times. */
	ZSTDLIBv07_API size_t ZSTDv07_decompress_usingDDict(ZSTDv07_DCtx* dctx,
	void* dst, size_t dstCapacity,
	const void* src, size_t srcSize,
	const ZSTDv07_DDict* ddict);

	typedef struct {
	unsigned long long frameContentSize;
	unsigned windowSize;
	unsigned dictID;
	unsigned checksumFlag;
	} ZSTDv07_frameParams;

	ZSTDLIBv07_API size_t ZSTDv07_getFrameParams(ZSTDv07_frameParams* fparamsPtr, const void* src, size_t srcSize); /*< doesn't consume input /




	/* *************************************
	* Streaming functions
	***************************************/
	typedef struct ZBUFFv07_DCtx_s ZBUFFv07_DCtx;
	ZSTDLIBv07_API ZBUFFv07_DCtx* ZBUFFv07_createDCtx(void);
	ZSTDLIBv07_API size_t ZBUFFv07_freeDCtx(ZBUFFv07_DCtx* dctx);

	ZSTDLIBv07_API size_t ZBUFFv07_decompressInit(ZBUFFv07_DCtx* dctx);
	ZSTDLIBv07_API size_t ZBUFFv07_decompressInitDictionary(ZBUFFv07_DCtx* dctx, const void* dict, size_t dictSize);

	ZSTDLIBv07_API size_t ZBUFFv07_decompressContinue(ZBUFFv07_DCtx* dctx,
	void* dst, size_t* dstCapacityPtr,
	const void* src, size_t* srcSizePtr);

	/-**************************************************************************
	* Streaming decompression howto
	*
	* A ZBUFFv07_DCtx object is required to track streaming operations.
	* Use ZBUFFv07_createDCtx() and ZBUFFv07_freeDCtx() to create/release resources.
	* Use ZBUFFv07_decompressInit() to start a new decompression operation,
	* or ZBUFFv07_decompressInitDictionary() if decompression requires a dictionary.
	* Note that ZBUFFv07_DCtx objects can be re-init multiple times.
	*
	* Use ZBUFFv07_decompressContinue() repetitively to consume your input.
	* srcSizePtr and dstCapacityPtr can be any size.
	* The function will report how many bytes were read or written by modifying srcSizePtr and dstCapacityPtr.
	* Note that it may not consume the entire input, in which case it's up to the caller to present remaining input again.
	* The content of `dst` will be overwritten (up to *dstCapacityPtr) at each function call, so save its content if it matters, or change `dst`.
	* @return : a hint to preferred nb of bytes to use as input for next function call (it's only a hint, to help latency),
	* or 0 when a frame is completely decoded,
	* or an error code, which can be tested using ZBUFFv07_isError().
	*
	* Hint : recommended buffer sizes (not compulsory) : ZBUFFv07_recommendedDInSize() and ZBUFFv07_recommendedDOutSize()
	* output : ZBUFFv07_recommendedDOutSize== 128 KB block size is the internal unit, it ensures it's always possible to write a full block when decoded.
	* input : ZBUFFv07_recommendedDInSize == 128KB + 3;
	* just follow indications from ZBUFFv07_decompressContinue() to minimize latency. It should always be <= 128 KB + 3 .
	* *******************************************************************************/


	/* *************************************
	* Tool functions
	***************************************/
	ZSTDLIBv07_API unsigned ZBUFFv07_isError(size_t errorCode);
	ZSTDLIBv07_API const char* ZBUFFv07_getErrorName(size_t errorCode);

	/** Functions below provide recommended buffer sizes for Compression or Decompression operations.
	* These sizes are just hints, they tend to offer better latency */
	ZSTDLIBv07_API size_t ZBUFFv07_recommendedDInSize(void);
	ZSTDLIBv07_API size_t ZBUFFv07_recommendedDOutSize(void);


	/-************************************
	* Constants
	***************************************/
	#define ZSTDv07_MAGICNUMBER 0xFD2FB527 /* v0.7 */


	#if defined (__cplusplus)
	}
	#endif

	#endif /* ZSTDv07_H_235446 */
	/** ended inlining zstd_v07.h **/
	#endif

	/** ZSTD_isLegacy() :
	@return : > 0 if supported by legacy decoder. 0 otherwise.
	return value is the version.
	*/
	MEM_STATIC unsigned ZSTD_isLegacy(const void* src, size_t srcSize)
	{
	U32 magicNumberLE;
	if (srcSize<4) return 0;
	magicNumberLE = MEM_readLE32(src);
	switch(magicNumberLE)
	{
	#if (ZSTD_LEGACY_SUPPORT <= 1)
	case ZSTDv01_magicNumberLE:return 1;
	#endif
	#if (ZSTD_LEGACY_SUPPORT <= 2)
	case ZSTDv02_magicNumber : return 2;
	#endif
	#if (ZSTD_LEGACY_SUPPORT <= 3)
	case ZSTDv03_magicNumber : return 3;
	#endif
	#if (ZSTD_LEGACY_SUPPORT <= 4)
	case ZSTDv04_magicNumber : return 4;
	#endif
	#if (ZSTD_LEGACY_SUPPORT <= 5)
	case ZSTDv05_MAGICNUMBER : return 5;
	#endif
	#if (ZSTD_LEGACY_SUPPORT <= 6)
	case ZSTDv06_MAGICNUMBER : return 6;
	#endif
	#if (ZSTD_LEGACY_SUPPORT <= 7)
	case ZSTDv07_MAGICNUMBER : return 7;
	#endif
	default : return 0;
	}
	}


	MEM_STATIC unsigned long long ZSTD_getDecompressedSize_legacy(const void* src, size_t srcSize)
	{
	U32 const version = ZSTD_isLegacy(src, srcSize);
	if (version < 5) return 0; /* no decompressed size in frame header, or not a legacy format */
	#if (ZSTD_LEGACY_SUPPORT <= 5)
	if (version==5) {
	ZSTDv05_parameters fParams;
	size_t const frResult = ZSTDv05_getFrameParams(&fParams, src, srcSize);
	if (frResult != 0) return 0;
	return fParams.srcSize;
	}
	#endif
	#if (ZSTD_LEGACY_SUPPORT <= 6)
	if (version==6) {
	ZSTDv06_frameParams fParams;
	size_t const frResult = ZSTDv06_getFrameParams(&fParams, src, srcSize);
	if (frResult != 0) return 0;
	return fParams.frameContentSize;
	}
	#endif
	#if (ZSTD_LEGACY_SUPPORT <= 7)
	if (version==7) {
	ZSTDv07_frameParams fParams;
	size_t const frResult = ZSTDv07_getFrameParams(&fParams, src, srcSize);
	if (frResult != 0) return 0;
	return fParams.frameContentSize;
	}
	#endif
	return 0; /* should not be possible */
	}


	MEM_STATIC size_t ZSTD_decompressLegacy(
	void* dst, size_t dstCapacity,
	const void* src, size_t compressedSize,
	const void* dict,size_t dictSize)
	{
	U32 const version = ZSTD_isLegacy(src, compressedSize);
	(void)dst; (void)dstCapacity; (void)dict; (void)dictSize; /* unused when ZSTD_LEGACY_SUPPORT >= 8 */
	switch(version)
	{
	#if (ZSTD_LEGACY_SUPPORT <= 1)
	case 1 :
	return ZSTDv01_decompress(dst, dstCapacity, src, compressedSize);
	#endif
	#if (ZSTD_LEGACY_SUPPORT <= 2)
	case 2 :
	return ZSTDv02_decompress(dst, dstCapacity, src, compressedSize);
	#endif
	#if (ZSTD_LEGACY_SUPPORT <= 3)
	case 3 :
	return ZSTDv03_decompress(dst, dstCapacity, src, compressedSize);
	#endif
	#if (ZSTD_LEGACY_SUPPORT <= 4)
	case 4 :
	return ZSTDv04_decompress(dst, dstCapacity, src, compressedSize);
	#endif
	#if (ZSTD_LEGACY_SUPPORT <= 5)
	case 5 :
	{ size_t result;
	ZSTDv05_DCtx* const zd = ZSTDv05_createDCtx();
	if (zd==NULL) return ERROR(memory_allocation);
	result = ZSTDv05_decompress_usingDict(zd, dst, dstCapacity, src, compressedSize, dict, dictSize);
	ZSTDv05_freeDCtx(zd);
	return result;
	}
	#endif
	#if (ZSTD_LEGACY_SUPPORT <= 6)
	case 6 :
	{ size_t result;
	ZSTDv06_DCtx* const zd = ZSTDv06_createDCtx();
	if (zd==NULL) return ERROR(memory_allocation);
	result = ZSTDv06_decompress_usingDict(zd, dst, dstCapacity, src, compressedSize, dict, dictSize);
	ZSTDv06_freeDCtx(zd);
	return result;
	}
	#endif
	#if (ZSTD_LEGACY_SUPPORT <= 7)
	case 7 :
	{ size_t result;
	ZSTDv07_DCtx* const zd = ZSTDv07_createDCtx();
	if (zd==NULL) return ERROR(memory_allocation);
	result = ZSTDv07_decompress_usingDict(zd, dst, dstCapacity, src, compressedSize, dict, dictSize);
	ZSTDv07_freeDCtx(zd);
	return result;
	}
	#endif
	default :
	return ERROR(prefix_unknown);
	}
	}

	MEM_STATIC ZSTD_frameSizeInfo ZSTD_findFrameSizeInfoLegacy(const void *src, size_t srcSize)
	{
	ZSTD_frameSizeInfo frameSizeInfo;
	U32 const version = ZSTD_isLegacy(src, srcSize);
	switch(version)
	{
	#if (ZSTD_LEGACY_SUPPORT <= 1)
	case 1 :
	ZSTDv01_findFrameSizeInfoLegacy(src, srcSize,
	&frameSizeInfo.compressedSize,
	&frameSizeInfo.decompressedBound);
	break;
	#endif
	#if (ZSTD_LEGACY_SUPPORT <= 2)
	case 2 :
	ZSTDv02_findFrameSizeInfoLegacy(src, srcSize,
	&frameSizeInfo.compressedSize,
	&frameSizeInfo.decompressedBound);
	break;
	#endif
	#if (ZSTD_LEGACY_SUPPORT <= 3)
	case 3 :
	ZSTDv03_findFrameSizeInfoLegacy(src, srcSize,
	&frameSizeInfo.compressedSize,
	&frameSizeInfo.decompressedBound);
	break;
	#endif
	#if (ZSTD_LEGACY_SUPPORT <= 4)
	case 4 :
	ZSTDv04_findFrameSizeInfoLegacy(src, srcSize,
	&frameSizeInfo.compressedSize,
	&frameSizeInfo.decompressedBound);
	break;
	#endif
	#if (ZSTD_LEGACY_SUPPORT <= 5)
	case 5 :
	ZSTDv05_findFrameSizeInfoLegacy(src, srcSize,
	&frameSizeInfo.compressedSize,
	&frameSizeInfo.decompressedBound);
	break;
	#endif
	#if (ZSTD_LEGACY_SUPPORT <= 6)
	case 6 :
	ZSTDv06_findFrameSizeInfoLegacy(src, srcSize,
	&frameSizeInfo.compressedSize,
	&frameSizeInfo.decompressedBound);
	break;
	#endif
	#if (ZSTD_LEGACY_SUPPORT <= 7)
	case 7 :
	ZSTDv07_findFrameSizeInfoLegacy(src, srcSize,
	&frameSizeInfo.compressedSize,
	&frameSizeInfo.decompressedBound);
	break;
	#endif
	default :
	frameSizeInfo.compressedSize = ERROR(prefix_unknown);
	frameSizeInfo.decompressedBound = ZSTD_CONTENTSIZE_ERROR;
	break;
	}
	if (!ZSTD_isError(frameSizeInfo.compressedSize) && frameSizeInfo.compressedSize > srcSize) {
	frameSizeInfo.compressedSize = ERROR(srcSize_wrong);
	frameSizeInfo.decompressedBound = ZSTD_CONTENTSIZE_ERROR;
	}
	return frameSizeInfo;
	}

	MEM_STATIC size_t ZSTD_findFrameCompressedSizeLegacy(const void *src, size_t srcSize)
	{
	ZSTD_frameSizeInfo frameSizeInfo = ZSTD_findFrameSizeInfoLegacy(src, srcSize);
	return frameSizeInfo.compressedSize;
	}

	MEM_STATIC size_t ZSTD_freeLegacyStreamContext(void* legacyContext, U32 version)
	{
	switch(version)
	{
	default :
	case 1 :
	case 2 :
	case 3 :
	(void)legacyContext;
	return ERROR(version_unsupported);
	#if (ZSTD_LEGACY_SUPPORT <= 4)
	case 4 : return ZBUFFv04_freeDCtx((ZBUFFv04_DCtx*)legacyContext);
	#endif
	#if (ZSTD_LEGACY_SUPPORT <= 5)
	case 5 : return ZBUFFv05_freeDCtx((ZBUFFv05_DCtx*)legacyContext);
	#endif
	#if (ZSTD_LEGACY_SUPPORT <= 6)
	case 6 : return ZBUFFv06_freeDCtx((ZBUFFv06_DCtx*)legacyContext);
	#endif
	#if (ZSTD_LEGACY_SUPPORT <= 7)
	case 7 : return ZBUFFv07_freeDCtx((ZBUFFv07_DCtx*)legacyContext);
	#endif
	}
	}


	MEM_STATIC size_t ZSTD_initLegacyStream(void** legacyContext, U32 prevVersion, U32 newVersion,
	const void* dict, size_t dictSize)
	{
	DEBUGLOG(5, "ZSTD_initLegacyStream for v0.%u", newVersion);
	if (prevVersion != newVersion) ZSTD_freeLegacyStreamContext(*legacyContext, prevVersion);
	switch(newVersion)
	{
	default :
	case 1 :
	case 2 :
	case 3 :
	(void)dict; (void)dictSize;
	return 0;
	#if (ZSTD_LEGACY_SUPPORT <= 4)
	case 4 :
	{
	ZBUFFv04_DCtx* dctx = (prevVersion != newVersion) ? ZBUFFv04_createDCtx() : (ZBUFFv04_DCtx)legacyContext;
	if (dctx==NULL) return ERROR(memory_allocation);
	ZBUFFv04_decompressInit(dctx);
	ZBUFFv04_decompressWithDictionary(dctx, dict, dictSize);
	*legacyContext = dctx;
	return 0;
	}
	#endif
	#if (ZSTD_LEGACY_SUPPORT <= 5)
	case 5 :
	{
	ZBUFFv05_DCtx* dctx = (prevVersion != newVersion) ? ZBUFFv05_createDCtx() : (ZBUFFv05_DCtx)legacyContext;
	if (dctx==NULL) return ERROR(memory_allocation);
	ZBUFFv05_decompressInitDictionary(dctx, dict, dictSize);
	*legacyContext = dctx;
	return 0;
	}
	#endif
	#if (ZSTD_LEGACY_SUPPORT <= 6)
	case 6 :
	{
	ZBUFFv06_DCtx* dctx = (prevVersion != newVersion) ? ZBUFFv06_createDCtx() : (ZBUFFv06_DCtx)legacyContext;
	if (dctx==NULL) return ERROR(memory_allocation);
	ZBUFFv06_decompressInitDictionary(dctx, dict, dictSize);
	*legacyContext = dctx;
	return 0;
	}
	#endif
	#if (ZSTD_LEGACY_SUPPORT <= 7)
	case 7 :
	{
	ZBUFFv07_DCtx* dctx = (prevVersion != newVersion) ? ZBUFFv07_createDCtx() : (ZBUFFv07_DCtx)legacyContext;
	if (dctx==NULL) return ERROR(memory_allocation);
	ZBUFFv07_decompressInitDictionary(dctx, dict, dictSize);
	*legacyContext = dctx;
	return 0;
	}
	#endif
	}
	}



	MEM_STATIC size_t ZSTD_decompressLegacyStream(void* legacyContext, U32 version,
	ZSTD_outBuffer* output, ZSTD_inBuffer* input)
	{
	DEBUGLOG(5, "ZSTD_decompressLegacyStream for v0.%u", version);
	switch(version)
	{
	default :
	case 1 :
	case 2 :
	case 3 :
	(void)legacyContext; (void)output; (void)input;
	return ERROR(version_unsupported);
	#if (ZSTD_LEGACY_SUPPORT <= 4)
	case 4 :
	{
	ZBUFFv04_DCtx* dctx = (ZBUFFv04_DCtx*) legacyContext;
	const void* src = (const char*)input->src + input->pos;
	size_t readSize = input->size - input->pos;
	void* dst = (char*)output->dst + output->pos;
	size_t decodedSize = output->size - output->pos;
	size_t const hintSize = ZBUFFv04_decompressContinue(dctx, dst, &decodedSize, src, &readSize);
	output->pos += decodedSize;
	input->pos += readSize;
	return hintSize;
	}
	#endif
	#if (ZSTD_LEGACY_SUPPORT <= 5)
	case 5 :
	{
	ZBUFFv05_DCtx* dctx = (ZBUFFv05_DCtx*) legacyContext;
	const void* src = (const char*)input->src + input->pos;
	size_t readSize = input->size - input->pos;
	void* dst = (char*)output->dst + output->pos;
	size_t decodedSize = output->size - output->pos;
	size_t const hintSize = ZBUFFv05_decompressContinue(dctx, dst, &decodedSize, src, &readSize);
	output->pos += decodedSize;
	input->pos += readSize;
	return hintSize;
	}
	#endif
	#if (ZSTD_LEGACY_SUPPORT <= 6)
	case 6 :
	{
	ZBUFFv06_DCtx* dctx = (ZBUFFv06_DCtx*) legacyContext;
	const void* src = (const char*)input->src + input->pos;
	size_t readSize = input->size - input->pos;
	void* dst = (char*)output->dst + output->pos;
	size_t decodedSize = output->size - output->pos;
	size_t const hintSize = ZBUFFv06_decompressContinue(dctx, dst, &decodedSize, src, &readSize);
	output->pos += decodedSize;
	input->pos += readSize;
	return hintSize;
	}
	#endif
	#if (ZSTD_LEGACY_SUPPORT <= 7)
	case 7 :
	{
	ZBUFFv07_DCtx* dctx = (ZBUFFv07_DCtx*) legacyContext;
	const void* src = (const char*)input->src + input->pos;
	size_t readSize = input->size - input->pos;
	void* dst = (char*)output->dst + output->pos;
	size_t decodedSize = output->size - output->pos;
	size_t const hintSize = ZBUFFv07_decompressContinue(dctx, dst, &decodedSize, src, &readSize);
	output->pos += decodedSize;
	input->pos += readSize;
	return hintSize;
	}
	#endif
	}
	}


	#if defined (__cplusplus)
	}
	#endif

	#endif /* ZSTD_LEGACY_H */
	/** ended inlining ../legacy/zstd_legacy.h **/
	#endif



	/-******************************************************
	* Types
	*********************************************************/
	struct ZSTD_DDict_s {
	void* dictBuffer;
	const void* dictContent;
	size_t dictSize;
	ZSTD_entropyDTables_t entropy;
	U32 dictID;
	U32 entropyPresent;
	ZSTD_customMem cMem;
	}; /* typedef'd to ZSTD_DDict within "zstd.h" */

	const void* ZSTD_DDict_dictContent(const ZSTD_DDict* ddict)
	{
	assert(ddict != NULL);
	return ddict->dictContent;
	}

	size_t ZSTD_DDict_dictSize(const ZSTD_DDict* ddict)
	{
	assert(ddict != NULL);
	return ddict->dictSize;
	}

	void ZSTD_copyDDictParameters(ZSTD_DCtx* dctx, const ZSTD_DDict* ddict)
	{
	DEBUGLOG(4, "ZSTD_copyDDictParameters");
	assert(dctx != NULL);
	assert(ddict != NULL);
	dctx->dictID = ddict->dictID;
	dctx->prefixStart = ddict->dictContent;
	dctx->virtualStart = ddict->dictContent;
	dctx->dictEnd = (const BYTE*)ddict->dictContent + ddict->dictSize;
	dctx->previousDstEnd = dctx->dictEnd;
	#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
	dctx->dictContentBeginForFuzzing = dctx->prefixStart;
	dctx->dictContentEndForFuzzing = dctx->previousDstEnd;
	#endif
	if (ddict->entropyPresent) {
	dctx->litEntropy = 1;
	dctx->fseEntropy = 1;
	dctx->LLTptr = ddict->entropy.LLTable;
	dctx->MLTptr = ddict->entropy.MLTable;
	dctx->OFTptr = ddict->entropy.OFTable;
	dctx->HUFptr = ddict->entropy.hufTable;
	dctx->entropy.rep[0] = ddict->entropy.rep[0];
	dctx->entropy.rep[1] = ddict->entropy.rep[1];
	dctx->entropy.rep[2] = ddict->entropy.rep[2];
	} else {
	dctx->litEntropy = 0;
	dctx->fseEntropy = 0;
	}
	}


	static size_t
	ZSTD_loadEntropy_intoDDict(ZSTD_DDict* ddict,
	ZSTD_dictContentType_e dictContentType)
	{
	ddict->dictID = 0;
	ddict->entropyPresent = 0;
	if (dictContentType == ZSTD_dct_rawContent) return 0;

	if (ddict->dictSize < 8) {
	if (dictContentType == ZSTD_dct_fullDict)
	return ERROR(dictionary_corrupted); /* only accept specified dictionaries */
	return 0; /* pure content mode */
	}
	{ U32 const magic = MEM_readLE32(ddict->dictContent);
	if (magic != ZSTD_MAGIC_DICTIONARY) {
	if (dictContentType == ZSTD_dct_fullDict)
	return ERROR(dictionary_corrupted); /* only accept specified dictionaries */
	return 0; /* pure content mode */
	}
	}
	ddict->dictID = MEM_readLE32((const char*)ddict->dictContent + ZSTD_FRAMEIDSIZE);

	/* load entropy tables */
	RETURN_ERROR_IF(ZSTD_isError(ZSTD_loadDEntropy(
	&ddict->entropy, ddict->dictContent, ddict->dictSize)),
	dictionary_corrupted, "");
	ddict->entropyPresent = 1;
	return 0;
	}


	static size_t ZSTD_initDDict_internal(ZSTD_DDict* ddict,
	const void* dict, size_t dictSize,
	ZSTD_dictLoadMethod_e dictLoadMethod,
	ZSTD_dictContentType_e dictContentType)
	{
	if ((dictLoadMethod == ZSTD_dlm_byRef) \|\| (!dict) \|\| (!dictSize)) {
	ddict->dictBuffer = NULL;
	ddict->dictContent = dict;
	if (!dict) dictSize = 0;
	} else {
	void* const internalBuffer = ZSTD_malloc(dictSize, ddict->cMem);
	ddict->dictBuffer = internalBuffer;
	ddict->dictContent = internalBuffer;
	if (!internalBuffer) return ERROR(memory_allocation);
	memcpy(internalBuffer, dict, dictSize);
	}
	ddict->dictSize = dictSize;
	ddict->entropy.hufTable[0] = (HUF_DTable)((HufLog)0x1000001); / cover both little and big endian */

	/* parse dictionary content */
	FORWARD_IF_ERROR( ZSTD_loadEntropy_intoDDict(ddict, dictContentType) , "");

	return 0;
	}

	ZSTD_DDict* ZSTD_createDDict_advanced(const void* dict, size_t dictSize,
	ZSTD_dictLoadMethod_e dictLoadMethod,
	ZSTD_dictContentType_e dictContentType,
	ZSTD_customMem customMem)
	{
	if (!customMem.customAlloc ^ !customMem.customFree) return NULL;

	{ ZSTD_DDict* const ddict = (ZSTD_DDict*) ZSTD_malloc(sizeof(ZSTD_DDict), customMem);
	if (ddict == NULL) return NULL;
	ddict->cMem = customMem;
	{ size_t const initResult = ZSTD_initDDict_internal(ddict,
	dict, dictSize,
	dictLoadMethod, dictContentType);
	if (ZSTD_isError(initResult)) {
	ZSTD_freeDDict(ddict);
	return NULL;
	} }
	return ddict;
	}
	}

	/*! ZSTD_createDDict() :
	* Create a digested dictionary, to start decompression without startup delay.
	* `dict` content is copied inside DDict.
	* Consequently, `dict` can be released after `ZSTD_DDict` creation */
	ZSTD_DDict* ZSTD_createDDict(const void* dict, size_t dictSize)
	{
	ZSTD_customMem const allocator = { NULL, NULL, NULL };
	return ZSTD_createDDict_advanced(dict, dictSize, ZSTD_dlm_byCopy, ZSTD_dct_auto, allocator);
	}

	/*! ZSTD_createDDict_byReference() :
	* Create a digested dictionary, to start decompression without startup delay.
	* Dictionary content is simply referenced, it will be accessed during decompression.
	* Warning : dictBuffer must outlive DDict (DDict must be freed before dictBuffer) */
	ZSTD_DDict* ZSTD_createDDict_byReference(const void* dictBuffer, size_t dictSize)
	{
	ZSTD_customMem const allocator = { NULL, NULL, NULL };
	return ZSTD_createDDict_advanced(dictBuffer, dictSize, ZSTD_dlm_byRef, ZSTD_dct_auto, allocator);
	}


	const ZSTD_DDict* ZSTD_initStaticDDict(
	void* sBuffer, size_t sBufferSize,
	const void* dict, size_t dictSize,
	ZSTD_dictLoadMethod_e dictLoadMethod,
	ZSTD_dictContentType_e dictContentType)
	{
	size_t const neededSpace = sizeof(ZSTD_DDict)
	+ (dictLoadMethod == ZSTD_dlm_byRef ? 0 : dictSize);
	ZSTD_DDict* const ddict = (ZSTD_DDict*)sBuffer;
	assert(sBuffer != NULL);
	assert(dict != NULL);
	if ((size_t)sBuffer & 7) return NULL; /* 8-aligned */
	if (sBufferSize < neededSpace) return NULL;
	if (dictLoadMethod == ZSTD_dlm_byCopy) {
	memcpy(ddict+1, dict, dictSize); /* local copy */
	dict = ddict+1;
	}
	if (ZSTD_isError( ZSTD_initDDict_internal(ddict,
	dict, dictSize,
	ZSTD_dlm_byRef, dictContentType) ))
	return NULL;
	return ddict;
	}


	size_t ZSTD_freeDDict(ZSTD_DDict* ddict)
	{
	if (ddict==NULL) return 0; /* support free on NULL */
	{ ZSTD_customMem const cMem = ddict->cMem;
	ZSTD_free(ddict->dictBuffer, cMem);
	ZSTD_free(ddict, cMem);
	return 0;
	}
	}

	/*! ZSTD_estimateDDictSize() :
	* Estimate amount of memory that will be needed to create a dictionary for decompression.
	* Note : dictionary created by reference using ZSTD_dlm_byRef are smaller */
	size_t ZSTD_estimateDDictSize(size_t dictSize, ZSTD_dictLoadMethod_e dictLoadMethod)
	{
	return sizeof(ZSTD_DDict) + (dictLoadMethod == ZSTD_dlm_byRef ? 0 : dictSize);
	}

	size_t ZSTD_sizeof_DDict(const ZSTD_DDict* ddict)
	{
	if (ddict==NULL) return 0; /* support sizeof on NULL */
	return sizeof(*ddict) + (ddict->dictBuffer ? ddict->dictSize : 0) ;
	}

	/*! ZSTD_getDictID_fromDDict() :
	* Provides the dictID of the dictionary loaded into `ddict`.
	* If @return == 0, the dictionary is not conformant to Zstandard specification, or empty.
	* Non-conformant dictionaries can still be loaded, but as content-only dictionaries. */
	unsigned ZSTD_getDictID_fromDDict(const ZSTD_DDict* ddict)
	{
	if (ddict==NULL) return 0;
	return ZSTD_getDictID_fromDict(ddict->dictContent, ddict->dictSize);
	}
	/** ended inlining decompress/zstd_ddict.c **/
	/** start inlining decompress/zstd_decompress.c **/
	/*
	* Copyright (c) 2016-2020, Yann Collet, Facebook, Inc.
	* All rights reserved.
	*
	* This source code is licensed under both the BSD-style license (found in the
	* LICENSE file in the root directory of this source tree) and the GPLv2 (found
	* in the COPYING file in the root directory of this source tree).
	* You may select, at your option, one of the above-listed licenses.
	*/


	/* ***************************************************************
	* Tuning parameters
	*****************************************************************/
	/*!
	* HEAPMODE :
	* Select how default decompression function ZSTD_decompress() allocates its context,
	* on stack (0), or into heap (1, default; requires malloc()).
	* Note that functions with explicit context such as ZSTD_decompressDCtx() are unaffected.
	*/
	#ifndef ZSTD_HEAPMODE
	# define ZSTD_HEAPMODE 1
	#endif

	/*!
	* LEGACY_SUPPORT :
	* if set to 1+, ZSTD_decompress() can decode older formats (v0.1+)
	*/
	#ifndef ZSTD_LEGACY_SUPPORT
	# define ZSTD_LEGACY_SUPPORT 0
	#endif

	/*!
	* MAXWINDOWSIZE_DEFAULT :
	* maximum window size accepted by DStream __by default__.
	* Frames requiring more memory will be rejected.
	* It's possible to set a different limit using ZSTD_DCtx_setMaxWindowSize().
	*/
	#ifndef ZSTD_MAXWINDOWSIZE_DEFAULT
	# define ZSTD_MAXWINDOWSIZE_DEFAULT (((U32)1 << ZSTD_WINDOWLOG_LIMIT_DEFAULT) + 1)
	#endif

	/*!
	* NO_FORWARD_PROGRESS_MAX :
	* maximum allowed nb of calls to ZSTD_decompressStream()
	* without any forward progress
	* (defined as: no byte read from input, and no byte flushed to output)
	* before triggering an error.
	*/
	#ifndef ZSTD_NO_FORWARD_PROGRESS_MAX
	# define ZSTD_NO_FORWARD_PROGRESS_MAX 16
	#endif


	/-******************************************************
	* Dependencies
	*********************************************************/
	#include <string.h> /* memcpy, memmove, memset */
	/** skipping file: ../common/cpu.h **/
	/** skipping file: ../common/mem.h **/
	#define FSE_STATIC_LINKING_ONLY
	/** skipping file: ../common/fse.h **/
	#define HUF_STATIC_LINKING_ONLY
	/** skipping file: ../common/huf.h **/
	/** skipping file: ../common/zstd_internal.h **/
	/** skipping file: zstd_decompress_internal.h **/
	/** skipping file: zstd_ddict.h **/
	/** start inlining zstd_decompress_block.h **/
	/*
	* Copyright (c) 2016-2020, Yann Collet, Facebook, Inc.
	* All rights reserved.
	*
	* This source code is licensed under both the BSD-style license (found in the
	* LICENSE file in the root directory of this source tree) and the GPLv2 (found
	* in the COPYING file in the root directory of this source tree).
	* You may select, at your option, one of the above-listed licenses.
	*/


	#ifndef ZSTD_DEC_BLOCK_H
	#define ZSTD_DEC_BLOCK_H

	/-******************************************************
	* Dependencies
	*********************************************************/
	#include <stddef.h> /* size_t */
	/** skipping file: ../zstd.h **/
	/** skipping file: ../common/zstd_internal.h **/
	/** skipping file: zstd_decompress_internal.h **/


	/* === Prototypes === */

	/* note: prototypes already published within `zstd.h` :
	* ZSTD_decompressBlock()
	*/

	/* note: prototypes already published within `zstd_internal.h` :
	* ZSTD_getcBlockSize()
	* ZSTD_decodeSeqHeaders()
	*/


	/* ZSTD_decompressBlock_internal() :
	* decompress block, starting at `src`,
	* into destination buffer `dst`.
	* @return : decompressed block size,
	* or an error code (which can be tested using ZSTD_isError())
	*/
	size_t ZSTD_decompressBlock_internal(ZSTD_DCtx* dctx,
	void* dst, size_t dstCapacity,
	const void* src, size_t srcSize, const int frame);

	/* ZSTD_buildFSETable() :
	* generate FSE decoding table for one symbol (ll, ml or off)
	* this function must be called with valid parameters only
	* (dt is large enough, normalizedCounter distribution total is a power of 2, max is within range, etc.)
	* in which case it cannot fail.
	* Internal use only.
	*/
	void ZSTD_buildFSETable(ZSTD_seqSymbol* dt,
	const short* normalizedCounter, unsigned maxSymbolValue,
	const U32* baseValue, const U32* nbAdditionalBits,
	unsigned tableLog);


	#endif /* ZSTD_DEC_BLOCK_H */
	/** ended inlining zstd_decompress_block.h **/

	#if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT>=1)
	/** skipping file: ../legacy/zstd_legacy.h **/
	#endif


	/-************************************************************
	* Context management
	***************************************************************/
	size_t ZSTD_sizeof_DCtx (const ZSTD_DCtx* dctx)
	{
	if (dctx==NULL) return 0; /* support sizeof NULL */
	return sizeof(*dctx)
	+ ZSTD_sizeof_DDict(dctx->ddictLocal)
	+ dctx->inBuffSize + dctx->outBuffSize;
	}

	size_t ZSTD_estimateDCtxSize(void) { return sizeof(ZSTD_DCtx); }


	static size_t ZSTD_startingInputLength(ZSTD_format_e format)
	{
	size_t const startingInputLength = ZSTD_FRAMEHEADERSIZE_PREFIX(format);
	/* only supports formats ZSTD_f_zstd1 and ZSTD_f_zstd1_magicless */
	assert( (format == ZSTD_f_zstd1) \|\| (format == ZSTD_f_zstd1_magicless) );
	return startingInputLength;
	}

	static void ZSTD_initDCtx_internal(ZSTD_DCtx* dctx)
	{
	dctx->format = ZSTD_f_zstd1; /* ZSTD_decompressBegin() invokes ZSTD_startingInputLength() with argument dctx->format */
	dctx->staticSize = 0;
	dctx->maxWindowSize = ZSTD_MAXWINDOWSIZE_DEFAULT;
	dctx->ddict = NULL;
	dctx->ddictLocal = NULL;
	dctx->dictEnd = NULL;
	dctx->ddictIsCold = 0;
	dctx->dictUses = ZSTD_dont_use;
	dctx->inBuff = NULL;
	dctx->inBuffSize = 0;
	dctx->outBuffSize = 0;
	dctx->streamStage = zdss_init;
	dctx->legacyContext = NULL;
	dctx->previousLegacyVersion = 0;
	dctx->noForwardProgress = 0;
	dctx->oversizedDuration = 0;
	dctx->bmi2 = ZSTD_cpuid_bmi2(ZSTD_cpuid());
	dctx->outBufferMode = ZSTD_obm_buffered;
	#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
	dctx->dictContentEndForFuzzing = NULL;
	#endif
	}

	ZSTD_DCtx* ZSTD_initStaticDCtx(void *workspace, size_t workspaceSize)
	{
	ZSTD_DCtx* const dctx = (ZSTD_DCtx*) workspace;

	if ((size_t)workspace & 7) return NULL; /* 8-aligned */
	if (workspaceSize < sizeof(ZSTD_DCtx)) return NULL; /* minimum size */

	ZSTD_initDCtx_internal(dctx);
	dctx->staticSize = workspaceSize;
	dctx->inBuff = (char*)(dctx+1);
	return dctx;
	}

	ZSTD_DCtx* ZSTD_createDCtx_advanced(ZSTD_customMem customMem)
	{
	if (!customMem.customAlloc ^ !customMem.customFree) return NULL;

	{ ZSTD_DCtx* const dctx = (ZSTD_DCtx)ZSTD_malloc(sizeof(dctx), customMem);
	if (!dctx) return NULL;
	dctx->customMem = customMem;
	ZSTD_initDCtx_internal(dctx);
	return dctx;
	}
	}

	ZSTD_DCtx* ZSTD_createDCtx(void)
	{
	DEBUGLOG(3, "ZSTD_createDCtx");
	return ZSTD_createDCtx_advanced(ZSTD_defaultCMem);
	}

	static void ZSTD_clearDict(ZSTD_DCtx* dctx)
	{
	ZSTD_freeDDict(dctx->ddictLocal);
	dctx->ddictLocal = NULL;
	dctx->ddict = NULL;
	dctx->dictUses = ZSTD_dont_use;
	}

	size_t ZSTD_freeDCtx(ZSTD_DCtx* dctx)
	{
	if (dctx==NULL) return 0; /* support free on NULL */
	RETURN_ERROR_IF(dctx->staticSize, memory_allocation, "not compatible with static DCtx");
	{ ZSTD_customMem const cMem = dctx->customMem;
	ZSTD_clearDict(dctx);
	ZSTD_free(dctx->inBuff, cMem);
	dctx->inBuff = NULL;
	#if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT >= 1)
	if (dctx->legacyContext)
	ZSTD_freeLegacyStreamContext(dctx->legacyContext, dctx->previousLegacyVersion);
	#endif
	ZSTD_free(dctx, cMem);
	return 0;
	}
	}

	/* no longer useful */
	void ZSTD_copyDCtx(ZSTD_DCtx* dstDCtx, const ZSTD_DCtx* srcDCtx)
	{
	size_t const toCopy = (size_t)((char)(&dstDCtx->inBuff) - (char)dstDCtx);
	memcpy(dstDCtx, srcDCtx, toCopy); /* no need to copy workspace */
	}


	/-************************************************************
	* Frame header decoding
	***************************************************************/

	/*! ZSTD_isFrame() :
	* Tells if the content of `buffer` starts with a valid Frame Identifier.
	* Note : Frame Identifier is 4 bytes. If `size < 4`, @return will always be 0.
	* Note 2 : Legacy Frame Identifiers are considered valid only if Legacy Support is enabled.
	* Note 3 : Skippable Frame Identifiers are considered valid. */
	unsigned ZSTD_isFrame(const void* buffer, size_t size)
	{
	if (size < ZSTD_FRAMEIDSIZE) return 0;
	{ U32 const magic = MEM_readLE32(buffer);
	if (magic == ZSTD_MAGICNUMBER) return 1;
	if ((magic & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) return 1;
	}
	#if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT >= 1)
	if (ZSTD_isLegacy(buffer, size)) return 1;
	#endif
	return 0;
	}

	/** ZSTD_frameHeaderSize_internal() :
	* srcSize must be large enough to reach header size fields.
	* note : only works for formats ZSTD_f_zstd1 and ZSTD_f_zstd1_magicless.
	* @return : size of the Frame Header
	* or an error code, which can be tested with ZSTD_isError() */
	static size_t ZSTD_frameHeaderSize_internal(const void* src, size_t srcSize, ZSTD_format_e format)
	{
	size_t const minInputSize = ZSTD_startingInputLength(format);
	RETURN_ERROR_IF(srcSize < minInputSize, srcSize_wrong, "");

	{ BYTE const fhd = ((const BYTE*)src)[minInputSize-1];
	U32 const dictID= fhd & 3;
	U32 const singleSegment = (fhd >> 5) & 1;
	U32 const fcsId = fhd >> 6;
	return minInputSize + !singleSegment
	+ ZSTD_did_fieldSize[dictID] + ZSTD_fcs_fieldSize[fcsId]
	+ (singleSegment && !fcsId);
	}
	}

	/** ZSTD_frameHeaderSize() :
	* srcSize must be >= ZSTD_frameHeaderSize_prefix.
	* @return : size of the Frame Header,
	* or an error code (if srcSize is too small) */
	size_t ZSTD_frameHeaderSize(const void* src, size_t srcSize)
	{
	return ZSTD_frameHeaderSize_internal(src, srcSize, ZSTD_f_zstd1);
	}


	/** ZSTD_getFrameHeader_advanced() :
	* decode Frame Header, or require larger `srcSize`.
	* note : only works for formats ZSTD_f_zstd1 and ZSTD_f_zstd1_magicless
	* @return : 0, `zfhPtr` is correctly filled,
	* >0, `srcSize` is too small, value is wanted `srcSize` amount,
	* or an error code, which can be tested using ZSTD_isError() */
	size_t ZSTD_getFrameHeader_advanced(ZSTD_frameHeader* zfhPtr, const void* src, size_t srcSize, ZSTD_format_e format)
	{
	const BYTE* ip = (const BYTE*)src;
	size_t const minInputSize = ZSTD_startingInputLength(format);

	memset(zfhPtr, 0, sizeof(zfhPtr)); / not strictly necessary, but static analyzer do not understand that zfhPtr is only going to be read only if return value is zero, since they are 2 different signals */
	if (srcSize < minInputSize) return minInputSize;
	RETURN_ERROR_IF(src==NULL, GENERIC, "invalid parameter");

	if ( (format != ZSTD_f_zstd1_magicless)
	&& (MEM_readLE32(src) != ZSTD_MAGICNUMBER) ) {
	if ((MEM_readLE32(src) & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) {
	/* skippable frame */
	if (srcSize < ZSTD_SKIPPABLEHEADERSIZE)
	return ZSTD_SKIPPABLEHEADERSIZE; /* magic number + frame length */
	memset(zfhPtr, 0, sizeof(*zfhPtr));
	zfhPtr->frameContentSize = MEM_readLE32((const char *)src + ZSTD_FRAMEIDSIZE);
	zfhPtr->frameType = ZSTD_skippableFrame;
	return 0;
	}
	RETURN_ERROR(prefix_unknown, "");
	}

	/* ensure there is enough `srcSize` to fully read/decode frame header */
	{ size_t const fhsize = ZSTD_frameHeaderSize_internal(src, srcSize, format);
	if (srcSize < fhsize) return fhsize;
	zfhPtr->headerSize = (U32)fhsize;
	}

	{ BYTE const fhdByte = ip[minInputSize-1];
	size_t pos = minInputSize;
	U32 const dictIDSizeCode = fhdByte&3;
	U32 const checksumFlag = (fhdByte>>2)&1;
	U32 const singleSegment = (fhdByte>>5)&1;
	U32 const fcsID = fhdByte>>6;
	U64 windowSize = 0;
	U32 dictID = 0;
	U64 frameContentSize = ZSTD_CONTENTSIZE_UNKNOWN;
	RETURN_ERROR_IF((fhdByte & 0x08) != 0, frameParameter_unsupported,
	"reserved bits, must be zero");

	if (!singleSegment) {
	BYTE const wlByte = ip[pos++];
	U32 const windowLog = (wlByte >> 3) + ZSTD_WINDOWLOG_ABSOLUTEMIN;
	RETURN_ERROR_IF(windowLog > ZSTD_WINDOWLOG_MAX, frameParameter_windowTooLarge, "");
	windowSize = (1ULL << windowLog);
	windowSize += (windowSize >> 3) * (wlByte&7);
	}
	switch(dictIDSizeCode)
	{
	default: assert(0); /* impossible */
	case 0 : break;
	case 1 : dictID = ip[pos]; pos++; break;
	case 2 : dictID = MEM_readLE16(ip+pos); pos+=2; break;
	case 3 : dictID = MEM_readLE32(ip+pos); pos+=4; break;
	}
	switch(fcsID)
	{
	default: assert(0); /* impossible */
	case 0 : if (singleSegment) frameContentSize = ip[pos]; break;
	case 1 : frameContentSize = MEM_readLE16(ip+pos)+256; break;
	case 2 : frameContentSize = MEM_readLE32(ip+pos); break;
	case 3 : frameContentSize = MEM_readLE64(ip+pos); break;
	}
	if (singleSegment) windowSize = frameContentSize;

	zfhPtr->frameType = ZSTD_frame;
	zfhPtr->frameContentSize = frameContentSize;
	zfhPtr->windowSize = windowSize;
	zfhPtr->blockSizeMax = (unsigned) MIN(windowSize, ZSTD_BLOCKSIZE_MAX);
	zfhPtr->dictID = dictID;
	zfhPtr->checksumFlag = checksumFlag;
	}
	return 0;
	}

	/** ZSTD_getFrameHeader() :
	* decode Frame Header, or require larger `srcSize`.
	* note : this function does not consume input, it only reads it.
	* @return : 0, `zfhPtr` is correctly filled,
	* >0, `srcSize` is too small, value is wanted `srcSize` amount,
	* or an error code, which can be tested using ZSTD_isError() */
	size_t ZSTD_getFrameHeader(ZSTD_frameHeader* zfhPtr, const void* src, size_t srcSize)
	{
	return ZSTD_getFrameHeader_advanced(zfhPtr, src, srcSize, ZSTD_f_zstd1);
	}


	/** ZSTD_getFrameContentSize() :
	* compatible with legacy mode
	* @return : decompressed size of the single frame pointed to be `src` if known, otherwise
	* - ZSTD_CONTENTSIZE_UNKNOWN if the size cannot be determined
	* - ZSTD_CONTENTSIZE_ERROR if an error occurred (e.g. invalid magic number, srcSize too small) */
	unsigned long long ZSTD_getFrameContentSize(const void *src, size_t srcSize)
	{
	#if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT >= 1)
	if (ZSTD_isLegacy(src, srcSize)) {
	unsigned long long const ret = ZSTD_getDecompressedSize_legacy(src, srcSize);
	return ret == 0 ? ZSTD_CONTENTSIZE_UNKNOWN : ret;
	}
	#endif
	{ ZSTD_frameHeader zfh;
	if (ZSTD_getFrameHeader(&zfh, src, srcSize) != 0)
	return ZSTD_CONTENTSIZE_ERROR;
	if (zfh.frameType == ZSTD_skippableFrame) {
	return 0;
	} else {
	return zfh.frameContentSize;
	} }
	}

	static size_t readSkippableFrameSize(void const* src, size_t srcSize)
	{
	size_t const skippableHeaderSize = ZSTD_SKIPPABLEHEADERSIZE;
	U32 sizeU32;

	RETURN_ERROR_IF(srcSize < ZSTD_SKIPPABLEHEADERSIZE, srcSize_wrong, "");

	sizeU32 = MEM_readLE32((BYTE const*)src + ZSTD_FRAMEIDSIZE);
	RETURN_ERROR_IF((U32)(sizeU32 + ZSTD_SKIPPABLEHEADERSIZE) < sizeU32,
	frameParameter_unsupported, "");
	{
	size_t const skippableSize = skippableHeaderSize + sizeU32;
	RETURN_ERROR_IF(skippableSize > srcSize, srcSize_wrong, "");
	return skippableSize;
	}
	}

	/** ZSTD_findDecompressedSize() :
	* compatible with legacy mode
	* `srcSize` must be the exact length of some number of ZSTD compressed and/or
	* skippable frames
	* @return : decompressed size of the frames contained */
	unsigned long long ZSTD_findDecompressedSize(const void* src, size_t srcSize)
	{
	unsigned long long totalDstSize = 0;

	while (srcSize >= ZSTD_startingInputLength(ZSTD_f_zstd1)) {
	U32 const magicNumber = MEM_readLE32(src);

	if ((magicNumber & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) {
	size_t const skippableSize = readSkippableFrameSize(src, srcSize);
	if (ZSTD_isError(skippableSize)) {
	return ZSTD_CONTENTSIZE_ERROR;
	}
	assert(skippableSize <= srcSize);

	src = (const BYTE *)src + skippableSize;
	srcSize -= skippableSize;
	continue;
	}

	{ unsigned long long const ret = ZSTD_getFrameContentSize(src, srcSize);
	if (ret >= ZSTD_CONTENTSIZE_ERROR) return ret;

	/* check for overflow */
	if (totalDstSize + ret < totalDstSize) return ZSTD_CONTENTSIZE_ERROR;
	totalDstSize += ret;
	}
	{ size_t const frameSrcSize = ZSTD_findFrameCompressedSize(src, srcSize);
	if (ZSTD_isError(frameSrcSize)) {
	return ZSTD_CONTENTSIZE_ERROR;
	}

	src = (const BYTE *)src + frameSrcSize;
	srcSize -= frameSrcSize;
	}
	} /* while (srcSize >= ZSTD_frameHeaderSize_prefix) */

	if (srcSize) return ZSTD_CONTENTSIZE_ERROR;

	return totalDstSize;
	}

	/** ZSTD_getDecompressedSize() :
	* compatible with legacy mode
	* @return : decompressed size if known, 0 otherwise
	note : 0 can mean any of the following :
	- frame content is empty
	- decompressed size field is not present in frame header
	- frame header unknown / not supported
	- frame header not complete (`srcSize` too small) */
	unsigned long long ZSTD_getDecompressedSize(const void* src, size_t srcSize)
	{
	unsigned long long const ret = ZSTD_getFrameContentSize(src, srcSize);
	ZSTD_STATIC_ASSERT(ZSTD_CONTENTSIZE_ERROR < ZSTD_CONTENTSIZE_UNKNOWN);
	return (ret >= ZSTD_CONTENTSIZE_ERROR) ? 0 : ret;
	}


	/** ZSTD_decodeFrameHeader() :
	* `headerSize` must be the size provided by ZSTD_frameHeaderSize().
	* @return : 0 if success, or an error code, which can be tested using ZSTD_isError() */
	static size_t ZSTD_decodeFrameHeader(ZSTD_DCtx* dctx, const void* src, size_t headerSize)
	{
	size_t const result = ZSTD_getFrameHeader_advanced(&(dctx->fParams), src, headerSize, dctx->format);
	if (ZSTD_isError(result)) return result; /* invalid header */
	RETURN_ERROR_IF(result>0, srcSize_wrong, "headerSize too small");
	#ifndef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
	/* Skip the dictID check in fuzzing mode, because it makes the search
	* harder.
	*/
	RETURN_ERROR_IF(dctx->fParams.dictID && (dctx->dictID != dctx->fParams.dictID),
	dictionary_wrong, "");
	#endif
	if (dctx->fParams.checksumFlag) XXH64_reset(&dctx->xxhState, 0);
	return 0;
	}

	static ZSTD_frameSizeInfo ZSTD_errorFrameSizeInfo(size_t ret)
	{
	ZSTD_frameSizeInfo frameSizeInfo;
	frameSizeInfo.compressedSize = ret;
	frameSizeInfo.decompressedBound = ZSTD_CONTENTSIZE_ERROR;
	return frameSizeInfo;
	}

	static ZSTD_frameSizeInfo ZSTD_findFrameSizeInfo(const void* src, size_t srcSize)
	{
	ZSTD_frameSizeInfo frameSizeInfo;
	memset(&frameSizeInfo, 0, sizeof(ZSTD_frameSizeInfo));

	#if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT >= 1)
	if (ZSTD_isLegacy(src, srcSize))
	return ZSTD_findFrameSizeInfoLegacy(src, srcSize);
	#endif

	if ((srcSize >= ZSTD_SKIPPABLEHEADERSIZE)
	&& (MEM_readLE32(src) & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) {
	frameSizeInfo.compressedSize = readSkippableFrameSize(src, srcSize);
	assert(ZSTD_isError(frameSizeInfo.compressedSize) \|\|
	frameSizeInfo.compressedSize <= srcSize);
	return frameSizeInfo;
	} else {
	const BYTE* ip = (const BYTE*)src;
	const BYTE* const ipstart = ip;
	size_t remainingSize = srcSize;
	size_t nbBlocks = 0;
	ZSTD_frameHeader zfh;

	/* Extract Frame Header */
	{ size_t const ret = ZSTD_getFrameHeader(&zfh, src, srcSize);
	if (ZSTD_isError(ret))
	return ZSTD_errorFrameSizeInfo(ret);
	if (ret > 0)
	return ZSTD_errorFrameSizeInfo(ERROR(srcSize_wrong));
	}

	ip += zfh.headerSize;
	remainingSize -= zfh.headerSize;

	/* Iterate over each block */
	while (1) {
	blockProperties_t blockProperties;
	size_t const cBlockSize = ZSTD_getcBlockSize(ip, remainingSize, &blockProperties);
	if (ZSTD_isError(cBlockSize))
	return ZSTD_errorFrameSizeInfo(cBlockSize);

	if (ZSTD_blockHeaderSize + cBlockSize > remainingSize)
	return ZSTD_errorFrameSizeInfo(ERROR(srcSize_wrong));

	ip += ZSTD_blockHeaderSize + cBlockSize;
	remainingSize -= ZSTD_blockHeaderSize + cBlockSize;
	nbBlocks++;

	if (blockProperties.lastBlock) break;
	}

	/* Final frame content checksum */
	if (zfh.checksumFlag) {
	if (remainingSize < 4)
	return ZSTD_errorFrameSizeInfo(ERROR(srcSize_wrong));
	ip += 4;
	}

	frameSizeInfo.compressedSize = ip - ipstart;
	frameSizeInfo.decompressedBound = (zfh.frameContentSize != ZSTD_CONTENTSIZE_UNKNOWN)
	? zfh.frameContentSize
	: nbBlocks * zfh.blockSizeMax;
	return frameSizeInfo;
	}
	}

	/** ZSTD_findFrameCompressedSize() :
	* compatible with legacy mode
	* `src` must point to the start of a ZSTD frame, ZSTD legacy frame, or skippable frame
	* `srcSize` must be at least as large as the frame contained
	* @return : the compressed size of the frame starting at `src` */
	size_t ZSTD_findFrameCompressedSize(const void *src, size_t srcSize)
	{
	ZSTD_frameSizeInfo const frameSizeInfo = ZSTD_findFrameSizeInfo(src, srcSize);
	return frameSizeInfo.compressedSize;
	}

	/** ZSTD_decompressBound() :
	* compatible with legacy mode
	* `src` must point to the start of a ZSTD frame or a skippeable frame
	* `srcSize` must be at least as large as the frame contained
	* @return : the maximum decompressed size of the compressed source
	*/
	unsigned long long ZSTD_decompressBound(const void* src, size_t srcSize)
	{
	unsigned long long bound = 0;
	/* Iterate over each frame */
	while (srcSize > 0) {
	ZSTD_frameSizeInfo const frameSizeInfo = ZSTD_findFrameSizeInfo(src, srcSize);
	size_t const compressedSize = frameSizeInfo.compressedSize;
	unsigned long long const decompressedBound = frameSizeInfo.decompressedBound;
	if (ZSTD_isError(compressedSize) \|\| decompressedBound == ZSTD_CONTENTSIZE_ERROR)
	return ZSTD_CONTENTSIZE_ERROR;
	assert(srcSize >= compressedSize);
	src = (const BYTE*)src + compressedSize;
	srcSize -= compressedSize;
	bound += decompressedBound;
	}
	return bound;
	}


	/-************************************************************
	* Frame decoding
	***************************************************************/

	/** ZSTD_insertBlock() :
	* insert `src` block into `dctx` history. Useful to track uncompressed blocks. */
	size_t ZSTD_insertBlock(ZSTD_DCtx* dctx, const void* blockStart, size_t blockSize)
	{
	DEBUGLOG(5, "ZSTD_insertBlock: %u bytes", (unsigned)blockSize);
	ZSTD_checkContinuity(dctx, blockStart);
	dctx->previousDstEnd = (const char*)blockStart + blockSize;
	return blockSize;
	}


	static size_t ZSTD_copyRawBlock(void* dst, size_t dstCapacity,
	const void* src, size_t srcSize)
	{
	DEBUGLOG(5, "ZSTD_copyRawBlock");
	if (dst == NULL) {
	if (srcSize == 0) return 0;
	RETURN_ERROR(dstBuffer_null, "");
	}
	RETURN_ERROR_IF(srcSize > dstCapacity, dstSize_tooSmall, "");
	memcpy(dst, src, srcSize);
	return srcSize;
	}

	static size_t ZSTD_setRleBlock(void* dst, size_t dstCapacity,
	BYTE b,
	size_t regenSize)
	{
	if (dst == NULL) {
	if (regenSize == 0) return 0;
	RETURN_ERROR(dstBuffer_null, "");
	}
	RETURN_ERROR_IF(regenSize > dstCapacity, dstSize_tooSmall, "");
	memset(dst, b, regenSize);
	return regenSize;
	}


	/*! ZSTD_decompressFrame() :
	* @dctx must be properly initialized
	* will update srcPtr and srcSizePtr,
	* to make srcPtr progress by one frame. /
	static size_t ZSTD_decompressFrame(ZSTD_DCtx* dctx,
	void* dst, size_t dstCapacity,
	const void** srcPtr, size_t *srcSizePtr)
	{
	const BYTE* ip = (const BYTE)(srcPtr);
	BYTE* const ostart = (BYTE* const)dst;
	BYTE* const oend = dstCapacity != 0 ? ostart + dstCapacity : ostart;
	BYTE* op = ostart;
	size_t remainingSrcSize = *srcSizePtr;

	DEBUGLOG(4, "ZSTD_decompressFrame (srcSize:%i)", (int)*srcSizePtr);

	/* check */
	RETURN_ERROR_IF(
	remainingSrcSize < ZSTD_FRAMEHEADERSIZE_MIN(dctx->format)+ZSTD_blockHeaderSize,
	srcSize_wrong, "");

	/* Frame Header */
	{ size_t const frameHeaderSize = ZSTD_frameHeaderSize_internal(
	ip, ZSTD_FRAMEHEADERSIZE_PREFIX(dctx->format), dctx->format);
	if (ZSTD_isError(frameHeaderSize)) return frameHeaderSize;
	RETURN_ERROR_IF(remainingSrcSize < frameHeaderSize+ZSTD_blockHeaderSize,
	srcSize_wrong, "");
	FORWARD_IF_ERROR( ZSTD_decodeFrameHeader(dctx, ip, frameHeaderSize) , "");
	ip += frameHeaderSize; remainingSrcSize -= frameHeaderSize;
	}

	/* Loop on each block */
	while (1) {
	size_t decodedSize;
	blockProperties_t blockProperties;
	size_t const cBlockSize = ZSTD_getcBlockSize(ip, remainingSrcSize, &blockProperties);
	if (ZSTD_isError(cBlockSize)) return cBlockSize;

	ip += ZSTD_blockHeaderSize;
	remainingSrcSize -= ZSTD_blockHeaderSize;
	RETURN_ERROR_IF(cBlockSize > remainingSrcSize, srcSize_wrong, "");

	switch(blockProperties.blockType)
	{
	case bt_compressed:
	decodedSize = ZSTD_decompressBlock_internal(dctx, op, oend-op, ip, cBlockSize, /* frame */ 1);
	break;
	case bt_raw :
	decodedSize = ZSTD_copyRawBlock(op, oend-op, ip, cBlockSize);
	break;
	case bt_rle :
	decodedSize = ZSTD_setRleBlock(op, oend-op, *ip, blockProperties.origSize);
	break;
	case bt_reserved :
	default:
	RETURN_ERROR(corruption_detected, "invalid block type");
	}

	if (ZSTD_isError(decodedSize)) return decodedSize;
	if (dctx->fParams.checksumFlag)
	XXH64_update(&dctx->xxhState, op, decodedSize);
	if (decodedSize != 0)
	op += decodedSize;
	assert(ip != NULL);
	ip += cBlockSize;
	remainingSrcSize -= cBlockSize;
	if (blockProperties.lastBlock) break;
	}

	if (dctx->fParams.frameContentSize != ZSTD_CONTENTSIZE_UNKNOWN) {
	RETURN_ERROR_IF((U64)(op-ostart) != dctx->fParams.frameContentSize,
	corruption_detected, "");
	}
	if (dctx->fParams.checksumFlag) { /* Frame content checksum verification */
	U32 const checkCalc = (U32)XXH64_digest(&dctx->xxhState);
	U32 checkRead;
	RETURN_ERROR_IF(remainingSrcSize<4, checksum_wrong, "");
	checkRead = MEM_readLE32(ip);
	RETURN_ERROR_IF(checkRead != checkCalc, checksum_wrong, "");
	ip += 4;
	remainingSrcSize -= 4;
	}

	/* Allow caller to get size read */
	*srcPtr = ip;
	*srcSizePtr = remainingSrcSize;
	return op-ostart;
	}

	static size_t ZSTD_decompressMultiFrame(ZSTD_DCtx* dctx,
	void* dst, size_t dstCapacity,
	const void* src, size_t srcSize,
	const void* dict, size_t dictSize,
	const ZSTD_DDict* ddict)
	{
	void* const dststart = dst;
	int moreThan1Frame = 0;

	DEBUGLOG(5, "ZSTD_decompressMultiFrame");
	assert(dict==NULL \|\| ddict==NULL); /* either dict or ddict set, not both */

	if (ddict) {
	dict = ZSTD_DDict_dictContent(ddict);
	dictSize = ZSTD_DDict_dictSize(ddict);
	}

	while (srcSize >= ZSTD_startingInputLength(dctx->format)) {

	#if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT >= 1)
	if (ZSTD_isLegacy(src, srcSize)) {
	size_t decodedSize;
	size_t const frameSize = ZSTD_findFrameCompressedSizeLegacy(src, srcSize);
	if (ZSTD_isError(frameSize)) return frameSize;
	RETURN_ERROR_IF(dctx->staticSize, memory_allocation,
	"legacy support is not compatible with static dctx");

	decodedSize = ZSTD_decompressLegacy(dst, dstCapacity, src, frameSize, dict, dictSize);
	if (ZSTD_isError(decodedSize)) return decodedSize;

	assert(decodedSize <=- dstCapacity);
	dst = (BYTE*)dst + decodedSize;
	dstCapacity -= decodedSize;

	src = (const BYTE*)src + frameSize;
	srcSize -= frameSize;

	continue;
	}
	#endif

	{ U32 const magicNumber = MEM_readLE32(src);
	DEBUGLOG(4, "reading magic number %08X (expecting %08X)",
	(unsigned)magicNumber, ZSTD_MAGICNUMBER);
	if ((magicNumber & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) {
	size_t const skippableSize = readSkippableFrameSize(src, srcSize);
	FORWARD_IF_ERROR(skippableSize, "readSkippableFrameSize failed");
	assert(skippableSize <= srcSize);

	src = (const BYTE *)src + skippableSize;
	srcSize -= skippableSize;
	continue;
	} }

	if (ddict) {
	/* we were called from ZSTD_decompress_usingDDict */
	FORWARD_IF_ERROR(ZSTD_decompressBegin_usingDDict(dctx, ddict), "");
	} else {
	/* this will initialize correctly with no dict if dict == NULL, so
	* use this in all cases but ddict */
	FORWARD_IF_ERROR(ZSTD_decompressBegin_usingDict(dctx, dict, dictSize), "");
	}
	ZSTD_checkContinuity(dctx, dst);

	{ const size_t res = ZSTD_decompressFrame(dctx, dst, dstCapacity,
	&src, &srcSize);
	RETURN_ERROR_IF(
	(ZSTD_getErrorCode(res) == ZSTD_error_prefix_unknown)
	&& (moreThan1Frame==1),
	srcSize_wrong,
	"at least one frame successfully completed, but following "
	"bytes are garbage: it's more likely to be a srcSize error, "
	"specifying more bytes than compressed size of frame(s). This "
	"error message replaces ERROR(prefix_unknown), which would be "
	"confusing, as the first header is actually correct. Note that "
	"one could be unlucky, it might be a corruption error instead, "
	"happening right at the place where we expect zstd magic "
	"bytes. But this is _much_ less likely than a srcSize field "
	"error.");
	if (ZSTD_isError(res)) return res;
	assert(res <= dstCapacity);
	if (res != 0)
	dst = (BYTE*)dst + res;
	dstCapacity -= res;
	}
	moreThan1Frame = 1;
	} /* while (srcSize >= ZSTD_frameHeaderSize_prefix) */

	RETURN_ERROR_IF(srcSize, srcSize_wrong, "input not entirely consumed");

	return (BYTE)dst - (BYTE)dststart;
	}

	size_t ZSTD_decompress_usingDict(ZSTD_DCtx* dctx,
	void* dst, size_t dstCapacity,
	const void* src, size_t srcSize,
	const void* dict, size_t dictSize)
	{
	return ZSTD_decompressMultiFrame(dctx, dst, dstCapacity, src, srcSize, dict, dictSize, NULL);
	}


	static ZSTD_DDict const* ZSTD_getDDict(ZSTD_DCtx* dctx)
	{
	switch (dctx->dictUses) {
	default:
	assert(0 /* Impossible */);
	/* fall-through */
	case ZSTD_dont_use:
	ZSTD_clearDict(dctx);
	return NULL;
	case ZSTD_use_indefinitely:
	return dctx->ddict;
	case ZSTD_use_once:
	dctx->dictUses = ZSTD_dont_use;
	return dctx->ddict;
	}
	}

	size_t ZSTD_decompressDCtx(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize)
	{
	return ZSTD_decompress_usingDDict(dctx, dst, dstCapacity, src, srcSize, ZSTD_getDDict(dctx));
	}


	size_t ZSTD_decompress(void* dst, size_t dstCapacity, const void* src, size_t srcSize)
	{
	#if defined(ZSTD_HEAPMODE) && (ZSTD_HEAPMODE>=1)
	size_t regenSize;
	ZSTD_DCtx* const dctx = ZSTD_createDCtx();
	RETURN_ERROR_IF(dctx==NULL, memory_allocation, "NULL pointer!");
	regenSize = ZSTD_decompressDCtx(dctx, dst, dstCapacity, src, srcSize);
	ZSTD_freeDCtx(dctx);
	return regenSize;
	#else /* stack mode */
	ZSTD_DCtx dctx;
	ZSTD_initDCtx_internal(&dctx);
	return ZSTD_decompressDCtx(&dctx, dst, dstCapacity, src, srcSize);
	#endif
	}


	/-*************************************
	* Advanced Streaming Decompression API
	* Bufferless and synchronous
	****************************************/
	size_t ZSTD_nextSrcSizeToDecompress(ZSTD_DCtx* dctx) { return dctx->expected; }

	/**
	* Similar to ZSTD_nextSrcSizeToDecompress(), but when when a block input can be streamed,
	* we allow taking a partial block as the input. Currently only raw uncompressed blocks can
	* be streamed.
	*
	* For blocks that can be streamed, this allows us to reduce the latency until we produce
	* output, and avoid copying the input.
	*
	* @param inputSize - The total amount of input that the caller currently has.
	*/
	static size_t ZSTD_nextSrcSizeToDecompressWithInputSize(ZSTD_DCtx* dctx, size_t inputSize) {
	if (!(dctx->stage == ZSTDds_decompressBlock \|\| dctx->stage == ZSTDds_decompressLastBlock))
	return dctx->expected;
	if (dctx->bType != bt_raw)
	return dctx->expected;
	return MIN(MAX(inputSize, 1), dctx->expected);
	}

	ZSTD_nextInputType_e ZSTD_nextInputType(ZSTD_DCtx* dctx) {
	switch(dctx->stage)
	{
	default: /* should not happen */
	assert(0);
	case ZSTDds_getFrameHeaderSize:
	case ZSTDds_decodeFrameHeader:
	return ZSTDnit_frameHeader;
	case ZSTDds_decodeBlockHeader:
	return ZSTDnit_blockHeader;
	case ZSTDds_decompressBlock:
	return ZSTDnit_block;
	case ZSTDds_decompressLastBlock:
	return ZSTDnit_lastBlock;
	case ZSTDds_checkChecksum:
	return ZSTDnit_checksum;
	case ZSTDds_decodeSkippableHeader:
	case ZSTDds_skipFrame:
	return ZSTDnit_skippableFrame;
	}
	}

	static int ZSTD_isSkipFrame(ZSTD_DCtx* dctx) { return dctx->stage == ZSTDds_skipFrame; }

	/** ZSTD_decompressContinue() :
	* srcSize : must be the exact nb of bytes expected (see ZSTD_nextSrcSizeToDecompress())
	* @return : nb of bytes generated into `dst` (necessarily <= `dstCapacity)
	* or an error code, which can be tested using ZSTD_isError() */
	size_t ZSTD_decompressContinue(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize)
	{
	DEBUGLOG(5, "ZSTD_decompressContinue (srcSize:%u)", (unsigned)srcSize);
	/* Sanity check */
	RETURN_ERROR_IF(srcSize != ZSTD_nextSrcSizeToDecompressWithInputSize(dctx, srcSize), srcSize_wrong, "not allowed");
	if (dstCapacity) ZSTD_checkContinuity(dctx, dst);

	switch (dctx->stage)
	{
	case ZSTDds_getFrameHeaderSize :
	assert(src != NULL);
	if (dctx->format == ZSTD_f_zstd1) { /* allows header */
	assert(srcSize >= ZSTD_FRAMEIDSIZE); /* to read skippable magic number */
	if ((MEM_readLE32(src) & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) { /* skippable frame */
	memcpy(dctx->headerBuffer, src, srcSize);
	dctx->expected = ZSTD_SKIPPABLEHEADERSIZE - srcSize; /* remaining to load to get full skippable frame header */
	dctx->stage = ZSTDds_decodeSkippableHeader;
	return 0;
	} }
	dctx->headerSize = ZSTD_frameHeaderSize_internal(src, srcSize, dctx->format);
	if (ZSTD_isError(dctx->headerSize)) return dctx->headerSize;
	memcpy(dctx->headerBuffer, src, srcSize);
	dctx->expected = dctx->headerSize - srcSize;
	dctx->stage = ZSTDds_decodeFrameHeader;
	return 0;

	case ZSTDds_decodeFrameHeader:
	assert(src != NULL);
	memcpy(dctx->headerBuffer + (dctx->headerSize - srcSize), src, srcSize);
	FORWARD_IF_ERROR(ZSTD_decodeFrameHeader(dctx, dctx->headerBuffer, dctx->headerSize), "");
	dctx->expected = ZSTD_blockHeaderSize;
	dctx->stage = ZSTDds_decodeBlockHeader;
	return 0;

	case ZSTDds_decodeBlockHeader:
	{ blockProperties_t bp;
	size_t const cBlockSize = ZSTD_getcBlockSize(src, ZSTD_blockHeaderSize, &bp);
	if (ZSTD_isError(cBlockSize)) return cBlockSize;
	RETURN_ERROR_IF(cBlockSize > dctx->fParams.blockSizeMax, corruption_detected, "Block Size Exceeds Maximum");
	dctx->expected = cBlockSize;
	dctx->bType = bp.blockType;
	dctx->rleSize = bp.origSize;
	if (cBlockSize) {
	dctx->stage = bp.lastBlock ? ZSTDds_decompressLastBlock : ZSTDds_decompressBlock;
	return 0;
	}
	/* empty block */
	if (bp.lastBlock) {
	if (dctx->fParams.checksumFlag) {
	dctx->expected = 4;
	dctx->stage = ZSTDds_checkChecksum;
	} else {
	dctx->expected = 0; /* end of frame */
	dctx->stage = ZSTDds_getFrameHeaderSize;
	}
	} else {
	dctx->expected = ZSTD_blockHeaderSize; /* jump to next header */
	dctx->stage = ZSTDds_decodeBlockHeader;
	}
	return 0;
	}

	case ZSTDds_decompressLastBlock:
	case ZSTDds_decompressBlock:
	DEBUGLOG(5, "ZSTD_decompressContinue: case ZSTDds_decompressBlock");
	{ size_t rSize;
	switch(dctx->bType)
	{
	case bt_compressed:
	DEBUGLOG(5, "ZSTD_decompressContinue: case bt_compressed");
	rSize = ZSTD_decompressBlock_internal(dctx, dst, dstCapacity, src, srcSize, /* frame */ 1);
	dctx->expected = 0; /* Streaming not supported */
	break;
	case bt_raw :
	assert(srcSize <= dctx->expected);
	rSize = ZSTD_copyRawBlock(dst, dstCapacity, src, srcSize);
	FORWARD_IF_ERROR(rSize, "ZSTD_copyRawBlock failed");
	assert(rSize == srcSize);
	dctx->expected -= rSize;
	break;
	case bt_rle :
	rSize = ZSTD_setRleBlock(dst, dstCapacity, (const BYTE)src, dctx->rleSize);
	dctx->expected = 0; /* Streaming not supported */
	break;
	case bt_reserved : /* should never happen */
	default:
	RETURN_ERROR(corruption_detected, "invalid block type");
	}
	FORWARD_IF_ERROR(rSize, "");
	RETURN_ERROR_IF(rSize > dctx->fParams.blockSizeMax, corruption_detected, "Decompressed Block Size Exceeds Maximum");
	DEBUGLOG(5, "ZSTD_decompressContinue: decoded size from block : %u", (unsigned)rSize);
	dctx->decodedSize += rSize;
	if (dctx->fParams.checksumFlag) XXH64_update(&dctx->xxhState, dst, rSize);
	dctx->previousDstEnd = (char*)dst + rSize;

	/* Stay on the same stage until we are finished streaming the block. */
	if (dctx->expected > 0) {
	return rSize;
	}

	if (dctx->stage == ZSTDds_decompressLastBlock) { /* end of frame */
	DEBUGLOG(4, "ZSTD_decompressContinue: decoded size from frame : %u", (unsigned)dctx->decodedSize);
	RETURN_ERROR_IF(
	dctx->fParams.frameContentSize != ZSTD_CONTENTSIZE_UNKNOWN
	&& dctx->decodedSize != dctx->fParams.frameContentSize,
	corruption_detected, "");
	if (dctx->fParams.checksumFlag) { /* another round for frame checksum */
	dctx->expected = 4;
	dctx->stage = ZSTDds_checkChecksum;
	} else {
	dctx->expected = 0; /* ends here */
	dctx->stage = ZSTDds_getFrameHeaderSize;
	}
	} else {
	dctx->stage = ZSTDds_decodeBlockHeader;
	dctx->expected = ZSTD_blockHeaderSize;
	}
	return rSize;
	}

	case ZSTDds_checkChecksum:
	assert(srcSize == 4); /* guaranteed by dctx->expected */
	{ U32 const h32 = (U32)XXH64_digest(&dctx->xxhState);
	U32 const check32 = MEM_readLE32(src);
	DEBUGLOG(4, "ZSTD_decompressContinue: checksum : calculated %08X :: %08X read", (unsigned)h32, (unsigned)check32);
	RETURN_ERROR_IF(check32 != h32, checksum_wrong, "");
	dctx->expected = 0;
	dctx->stage = ZSTDds_getFrameHeaderSize;
	return 0;
	}

	case ZSTDds_decodeSkippableHeader:
	assert(src != NULL);
	assert(srcSize <= ZSTD_SKIPPABLEHEADERSIZE);
	memcpy(dctx->headerBuffer + (ZSTD_SKIPPABLEHEADERSIZE - srcSize), src, srcSize); /* complete skippable header */
	dctx->expected = MEM_readLE32(dctx->headerBuffer + ZSTD_FRAMEIDSIZE); /* note : dctx->expected can grow seriously large, beyond local buffer size */
	dctx->stage = ZSTDds_skipFrame;
	return 0;

	case ZSTDds_skipFrame:
	dctx->expected = 0;
	dctx->stage = ZSTDds_getFrameHeaderSize;
	return 0;

	default:
	assert(0); /* impossible */
	RETURN_ERROR(GENERIC, "impossible to reach"); /* some compiler require default to do something */
	}
	}


	static size_t ZSTD_refDictContent(ZSTD_DCtx* dctx, const void* dict, size_t dictSize)
	{
	dctx->dictEnd = dctx->previousDstEnd;
	dctx->virtualStart = (const char)dict - ((const char)(dctx->previousDstEnd) - (const char*)(dctx->prefixStart));
	dctx->prefixStart = dict;
	dctx->previousDstEnd = (const char*)dict + dictSize;
	#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
	dctx->dictContentBeginForFuzzing = dctx->prefixStart;
	dctx->dictContentEndForFuzzing = dctx->previousDstEnd;
	#endif
	return 0;
	}

	/*! ZSTD_loadDEntropy() :
	* dict : must point at beginning of a valid zstd dictionary.
	* @return : size of entropy tables read */
	size_t
	ZSTD_loadDEntropy(ZSTD_entropyDTables_t* entropy,
	const void* const dict, size_t const dictSize)
	{
	const BYTE* dictPtr = (const BYTE*)dict;
	const BYTE* const dictEnd = dictPtr + dictSize;

	RETURN_ERROR_IF(dictSize <= 8, dictionary_corrupted, "dict is too small");
	assert(MEM_readLE32(dict) == ZSTD_MAGIC_DICTIONARY); /* dict must be valid */
	dictPtr += 8; /* skip header = magic + dictID */

	ZSTD_STATIC_ASSERT(offsetof(ZSTD_entropyDTables_t, OFTable) == offsetof(ZSTD_entropyDTables_t, LLTable) + sizeof(entropy->LLTable));
	ZSTD_STATIC_ASSERT(offsetof(ZSTD_entropyDTables_t, MLTable) == offsetof(ZSTD_entropyDTables_t, OFTable) + sizeof(entropy->OFTable));
	ZSTD_STATIC_ASSERT(sizeof(entropy->LLTable) + sizeof(entropy->OFTable) + sizeof(entropy->MLTable) >= HUF_DECOMPRESS_WORKSPACE_SIZE);
	{ void* const workspace = &entropy->LLTable; /* use fse tables as temporary workspace; implies fse tables are grouped together */
	size_t const workspaceSize = sizeof(entropy->LLTable) + sizeof(entropy->OFTable) + sizeof(entropy->MLTable);
	#ifdef HUF_FORCE_DECOMPRESS_X1
	/* in minimal huffman, we always use X1 variants */
	size_t const hSize = HUF_readDTableX1_wksp(entropy->hufTable,
	dictPtr, dictEnd - dictPtr,
	workspace, workspaceSize);
	#else
	size_t const hSize = HUF_readDTableX2_wksp(entropy->hufTable,
	dictPtr, dictEnd - dictPtr,
	workspace, workspaceSize);
	#endif
	RETURN_ERROR_IF(HUF_isError(hSize), dictionary_corrupted, "");
	dictPtr += hSize;
	}

	{ short offcodeNCount[MaxOff+1];
	unsigned offcodeMaxValue = MaxOff, offcodeLog;
	size_t const offcodeHeaderSize = FSE_readNCount(offcodeNCount, &offcodeMaxValue, &offcodeLog, dictPtr, dictEnd-dictPtr);
	RETURN_ERROR_IF(FSE_isError(offcodeHeaderSize), dictionary_corrupted, "");
	RETURN_ERROR_IF(offcodeMaxValue > MaxOff, dictionary_corrupted, "");
	RETURN_ERROR_IF(offcodeLog > OffFSELog, dictionary_corrupted, "");
	ZSTD_buildFSETable( entropy->OFTable,
	offcodeNCount, offcodeMaxValue,
	OF_base, OF_bits,
	offcodeLog);
	dictPtr += offcodeHeaderSize;
	}

	{ short matchlengthNCount[MaxML+1];
	unsigned matchlengthMaxValue = MaxML, matchlengthLog;
	size_t const matchlengthHeaderSize = FSE_readNCount(matchlengthNCount, &matchlengthMaxValue, &matchlengthLog, dictPtr, dictEnd-dictPtr);
	RETURN_ERROR_IF(FSE_isError(matchlengthHeaderSize), dictionary_corrupted, "");
	RETURN_ERROR_IF(matchlengthMaxValue > MaxML, dictionary_corrupted, "");
	RETURN_ERROR_IF(matchlengthLog > MLFSELog, dictionary_corrupted, "");
	ZSTD_buildFSETable( entropy->MLTable,
	matchlengthNCount, matchlengthMaxValue,
	ML_base, ML_bits,
	matchlengthLog);
	dictPtr += matchlengthHeaderSize;
	}

	{ short litlengthNCount[MaxLL+1];
	unsigned litlengthMaxValue = MaxLL, litlengthLog;
	size_t const litlengthHeaderSize = FSE_readNCount(litlengthNCount, &litlengthMaxValue, &litlengthLog, dictPtr, dictEnd-dictPtr);
	RETURN_ERROR_IF(FSE_isError(litlengthHeaderSize), dictionary_corrupted, "");
	RETURN_ERROR_IF(litlengthMaxValue > MaxLL, dictionary_corrupted, "");
	RETURN_ERROR_IF(litlengthLog > LLFSELog, dictionary_corrupted, "");
	ZSTD_buildFSETable( entropy->LLTable,
	litlengthNCount, litlengthMaxValue,
	LL_base, LL_bits,
	litlengthLog);
	dictPtr += litlengthHeaderSize;
	}

	RETURN_ERROR_IF(dictPtr+12 > dictEnd, dictionary_corrupted, "");
	{ int i;
	size_t const dictContentSize = (size_t)(dictEnd - (dictPtr+12));
	for (i=0; i<3; i++) {
	U32 const rep = MEM_readLE32(dictPtr); dictPtr += 4;
	RETURN_ERROR_IF(rep==0 \|\| rep > dictContentSize,
	dictionary_corrupted, "");
	entropy->rep[i] = rep;
	} }

	return dictPtr - (const BYTE*)dict;
	}

	static size_t ZSTD_decompress_insertDictionary(ZSTD_DCtx* dctx, const void* dict, size_t dictSize)
	{
	if (dictSize < 8) return ZSTD_refDictContent(dctx, dict, dictSize);
	{ U32 const magic = MEM_readLE32(dict);
	if (magic != ZSTD_MAGIC_DICTIONARY) {
	return ZSTD_refDictContent(dctx, dict, dictSize); /* pure content mode */
	} }
	dctx->dictID = MEM_readLE32((const char*)dict + ZSTD_FRAMEIDSIZE);

	/* load entropy tables */
	{ size_t const eSize = ZSTD_loadDEntropy(&dctx->entropy, dict, dictSize);
	RETURN_ERROR_IF(ZSTD_isError(eSize), dictionary_corrupted, "");
	dict = (const char*)dict + eSize;
	dictSize -= eSize;
	}
	dctx->litEntropy = dctx->fseEntropy = 1;

	/* reference dictionary content */
	return ZSTD_refDictContent(dctx, dict, dictSize);
	}

	size_t ZSTD_decompressBegin(ZSTD_DCtx* dctx)
	{
	assert(dctx != NULL);
	dctx->expected = ZSTD_startingInputLength(dctx->format); /* dctx->format must be properly set */
	dctx->stage = ZSTDds_getFrameHeaderSize;
	dctx->decodedSize = 0;
	dctx->previousDstEnd = NULL;
	dctx->prefixStart = NULL;
	dctx->virtualStart = NULL;
	dctx->dictEnd = NULL;
	dctx->entropy.hufTable[0] = (HUF_DTable)((HufLog)0x1000001); / cover both little and big endian */
	dctx->litEntropy = dctx->fseEntropy = 0;
	dctx->dictID = 0;
	dctx->bType = bt_reserved;
	ZSTD_STATIC_ASSERT(sizeof(dctx->entropy.rep) == sizeof(repStartValue));
	memcpy(dctx->entropy.rep, repStartValue, sizeof(repStartValue)); /* initial repcodes */
	dctx->LLTptr = dctx->entropy.LLTable;
	dctx->MLTptr = dctx->entropy.MLTable;
	dctx->OFTptr = dctx->entropy.OFTable;
	dctx->HUFptr = dctx->entropy.hufTable;
	return 0;
	}

	size_t ZSTD_decompressBegin_usingDict(ZSTD_DCtx* dctx, const void* dict, size_t dictSize)
	{
	FORWARD_IF_ERROR( ZSTD_decompressBegin(dctx) , "");
	if (dict && dictSize)
	RETURN_ERROR_IF(
	ZSTD_isError(ZSTD_decompress_insertDictionary(dctx, dict, dictSize)),
	dictionary_corrupted, "");
	return 0;
	}


	/* ====== ZSTD_DDict ====== */

	size_t ZSTD_decompressBegin_usingDDict(ZSTD_DCtx* dctx, const ZSTD_DDict* ddict)
	{
	DEBUGLOG(4, "ZSTD_decompressBegin_usingDDict");
	assert(dctx != NULL);
	if (ddict) {
	const char* const dictStart = (const char*)ZSTD_DDict_dictContent(ddict);
	size_t const dictSize = ZSTD_DDict_dictSize(ddict);
	const void* const dictEnd = dictStart + dictSize;
	dctx->ddictIsCold = (dctx->dictEnd != dictEnd);
	DEBUGLOG(4, "DDict is %s",
	dctx->ddictIsCold ? "~cold~" : "hot!");
	}
	FORWARD_IF_ERROR( ZSTD_decompressBegin(dctx) , "");
	if (ddict) { /* NULL ddict is equivalent to no dictionary */
	ZSTD_copyDDictParameters(dctx, ddict);
	}
	return 0;
	}

	/*! ZSTD_getDictID_fromDict() :
	* Provides the dictID stored within dictionary.
	* if @return == 0, the dictionary is not conformant with Zstandard specification.
	* It can still be loaded, but as a content-only dictionary. */
	unsigned ZSTD_getDictID_fromDict(const void* dict, size_t dictSize)
	{
	if (dictSize < 8) return 0;
	if (MEM_readLE32(dict) != ZSTD_MAGIC_DICTIONARY) return 0;
	return MEM_readLE32((const char*)dict + ZSTD_FRAMEIDSIZE);
	}

	/*! ZSTD_getDictID_fromFrame() :
	* Provides the dictID required to decompress frame stored within `src`.
	* If @return == 0, the dictID could not be decoded.
	* This could for one of the following reasons :
	* - The frame does not require a dictionary (most common case).
	* - The frame was built with dictID intentionally removed.
	* Needed dictionary is a hidden information.
	* Note : this use case also happens when using a non-conformant dictionary.
	* - `srcSize` is too small, and as a result, frame header could not be decoded.
	* Note : possible if `srcSize < ZSTD_FRAMEHEADERSIZE_MAX`.
	* - This is not a Zstandard frame.
	* When identifying the exact failure cause, it's possible to use
	* ZSTD_getFrameHeader(), which will provide a more precise error code. */
	unsigned ZSTD_getDictID_fromFrame(const void* src, size_t srcSize)
	{
	ZSTD_frameHeader zfp = { 0, 0, 0, ZSTD_frame, 0, 0, 0 };
	size_t const hError = ZSTD_getFrameHeader(&zfp, src, srcSize);
	if (ZSTD_isError(hError)) return 0;
	return zfp.dictID;
	}


	/*! ZSTD_decompress_usingDDict() :
	* Decompression using a pre-digested Dictionary
	* Use dictionary without significant overhead. */
	size_t ZSTD_decompress_usingDDict(ZSTD_DCtx* dctx,
	void* dst, size_t dstCapacity,
	const void* src, size_t srcSize,
	const ZSTD_DDict* ddict)
	{
	/* pass content and size in case legacy frames are encountered */
	return ZSTD_decompressMultiFrame(dctx, dst, dstCapacity, src, srcSize,
	NULL, 0,
	ddict);
	}


	/*=====================================
	* Streaming decompression
	====================================/

	ZSTD_DStream* ZSTD_createDStream(void)
	{
	DEBUGLOG(3, "ZSTD_createDStream");
	return ZSTD_createDStream_advanced(ZSTD_defaultCMem);
	}

	ZSTD_DStream* ZSTD_initStaticDStream(void *workspace, size_t workspaceSize)
	{
	return ZSTD_initStaticDCtx(workspace, workspaceSize);
	}

	ZSTD_DStream* ZSTD_createDStream_advanced(ZSTD_customMem customMem)
	{
	return ZSTD_createDCtx_advanced(customMem);
	}

	size_t ZSTD_freeDStream(ZSTD_DStream* zds)
	{
	return ZSTD_freeDCtx(zds);
	}


	/* * Initialization * */

	size_t ZSTD_DStreamInSize(void) { return ZSTD_BLOCKSIZE_MAX + ZSTD_blockHeaderSize; }
	size_t ZSTD_DStreamOutSize(void) { return ZSTD_BLOCKSIZE_MAX; }

	size_t ZSTD_DCtx_loadDictionary_advanced(ZSTD_DCtx* dctx,
	const void* dict, size_t dictSize,
	ZSTD_dictLoadMethod_e dictLoadMethod,
	ZSTD_dictContentType_e dictContentType)
	{
	RETURN_ERROR_IF(dctx->streamStage != zdss_init, stage_wrong, "");
	ZSTD_clearDict(dctx);
	if (dict && dictSize != 0) {
	dctx->ddictLocal = ZSTD_createDDict_advanced(dict, dictSize, dictLoadMethod, dictContentType, dctx->customMem);
	RETURN_ERROR_IF(dctx->ddictLocal == NULL, memory_allocation, "NULL pointer!");
	dctx->ddict = dctx->ddictLocal;
	dctx->dictUses = ZSTD_use_indefinitely;
	}
	return 0;
	}

	size_t ZSTD_DCtx_loadDictionary_byReference(ZSTD_DCtx* dctx, const void* dict, size_t dictSize)
	{
	return ZSTD_DCtx_loadDictionary_advanced(dctx, dict, dictSize, ZSTD_dlm_byRef, ZSTD_dct_auto);
	}

	size_t ZSTD_DCtx_loadDictionary(ZSTD_DCtx* dctx, const void* dict, size_t dictSize)
	{
	return ZSTD_DCtx_loadDictionary_advanced(dctx, dict, dictSize, ZSTD_dlm_byCopy, ZSTD_dct_auto);
	}

	size_t ZSTD_DCtx_refPrefix_advanced(ZSTD_DCtx* dctx, const void* prefix, size_t prefixSize, ZSTD_dictContentType_e dictContentType)
	{
	FORWARD_IF_ERROR(ZSTD_DCtx_loadDictionary_advanced(dctx, prefix, prefixSize, ZSTD_dlm_byRef, dictContentType), "");
	dctx->dictUses = ZSTD_use_once;
	return 0;
	}

	size_t ZSTD_DCtx_refPrefix(ZSTD_DCtx* dctx, const void* prefix, size_t prefixSize)
	{
	return ZSTD_DCtx_refPrefix_advanced(dctx, prefix, prefixSize, ZSTD_dct_rawContent);
	}


	/* ZSTD_initDStream_usingDict() :
	* return : expected size, aka ZSTD_startingInputLength().
	* this function cannot fail */
	size_t ZSTD_initDStream_usingDict(ZSTD_DStream* zds, const void* dict, size_t dictSize)
	{
	DEBUGLOG(4, "ZSTD_initDStream_usingDict");
	FORWARD_IF_ERROR( ZSTD_DCtx_reset(zds, ZSTD_reset_session_only) , "");
	FORWARD_IF_ERROR( ZSTD_DCtx_loadDictionary(zds, dict, dictSize) , "");
	return ZSTD_startingInputLength(zds->format);
	}

	/* note : this variant can't fail */
	size_t ZSTD_initDStream(ZSTD_DStream* zds)
	{
	DEBUGLOG(4, "ZSTD_initDStream");
	return ZSTD_initDStream_usingDDict(zds, NULL);
	}

	/* ZSTD_initDStream_usingDDict() :
	* ddict will just be referenced, and must outlive decompression session
	* this function cannot fail */
	size_t ZSTD_initDStream_usingDDict(ZSTD_DStream* dctx, const ZSTD_DDict* ddict)
	{
	FORWARD_IF_ERROR( ZSTD_DCtx_reset(dctx, ZSTD_reset_session_only) , "");
	FORWARD_IF_ERROR( ZSTD_DCtx_refDDict(dctx, ddict) , "");
	return ZSTD_startingInputLength(dctx->format);
	}

	/* ZSTD_resetDStream() :
	* return : expected size, aka ZSTD_startingInputLength().
	* this function cannot fail */
	size_t ZSTD_resetDStream(ZSTD_DStream* dctx)
	{
	FORWARD_IF_ERROR(ZSTD_DCtx_reset(dctx, ZSTD_reset_session_only), "");
	return ZSTD_startingInputLength(dctx->format);
	}


	size_t ZSTD_DCtx_refDDict(ZSTD_DCtx* dctx, const ZSTD_DDict* ddict)
	{
	RETURN_ERROR_IF(dctx->streamStage != zdss_init, stage_wrong, "");
	ZSTD_clearDict(dctx);
	if (ddict) {
	dctx->ddict = ddict;
	dctx->dictUses = ZSTD_use_indefinitely;
	}
	return 0;
	}

	/* ZSTD_DCtx_setMaxWindowSize() :
	* note : no direct equivalence in ZSTD_DCtx_setParameter,
	* since this version sets windowSize, and the other sets windowLog */
	size_t ZSTD_DCtx_setMaxWindowSize(ZSTD_DCtx* dctx, size_t maxWindowSize)
	{
	ZSTD_bounds const bounds = ZSTD_dParam_getBounds(ZSTD_d_windowLogMax);
	size_t const min = (size_t)1 << bounds.lowerBound;
	size_t const max = (size_t)1 << bounds.upperBound;
	RETURN_ERROR_IF(dctx->streamStage != zdss_init, stage_wrong, "");
	RETURN_ERROR_IF(maxWindowSize < min, parameter_outOfBound, "");
	RETURN_ERROR_IF(maxWindowSize > max, parameter_outOfBound, "");
	dctx->maxWindowSize = maxWindowSize;
	return 0;
	}

	size_t ZSTD_DCtx_setFormat(ZSTD_DCtx* dctx, ZSTD_format_e format)
	{
	return ZSTD_DCtx_setParameter(dctx, ZSTD_d_format, format);
	}

	ZSTD_bounds ZSTD_dParam_getBounds(ZSTD_dParameter dParam)
	{
	ZSTD_bounds bounds = { 0, 0, 0 };
	switch(dParam) {
	case ZSTD_d_windowLogMax:
	bounds.lowerBound = ZSTD_WINDOWLOG_ABSOLUTEMIN;
	bounds.upperBound = ZSTD_WINDOWLOG_MAX;
	return bounds;
	case ZSTD_d_format:
	bounds.lowerBound = (int)ZSTD_f_zstd1;
	bounds.upperBound = (int)ZSTD_f_zstd1_magicless;
	ZSTD_STATIC_ASSERT(ZSTD_f_zstd1 < ZSTD_f_zstd1_magicless);
	return bounds;
	case ZSTD_d_stableOutBuffer:
	bounds.lowerBound = (int)ZSTD_obm_buffered;
	bounds.upperBound = (int)ZSTD_obm_stable;
	return bounds;
	default:;
	}
	bounds.error = ERROR(parameter_unsupported);
	return bounds;
	}

	/* ZSTD_dParam_withinBounds:
	* @return 1 if value is within dParam bounds,
	* 0 otherwise */
	static int ZSTD_dParam_withinBounds(ZSTD_dParameter dParam, int value)
	{
	ZSTD_bounds const bounds = ZSTD_dParam_getBounds(dParam);
	if (ZSTD_isError(bounds.error)) return 0;
	if (value < bounds.lowerBound) return 0;
	if (value > bounds.upperBound) return 0;
	return 1;
	}

	#define CHECK_DBOUNDS(p,v) { \
	RETURN_ERROR_IF(!ZSTD_dParam_withinBounds(p, v), parameter_outOfBound, ""); \
	}

	size_t ZSTD_DCtx_setParameter(ZSTD_DCtx* dctx, ZSTD_dParameter dParam, int value)
	{
	RETURN_ERROR_IF(dctx->streamStage != zdss_init, stage_wrong, "");
	switch(dParam) {
	case ZSTD_d_windowLogMax:
	if (value == 0) value = ZSTD_WINDOWLOG_LIMIT_DEFAULT;
	CHECK_DBOUNDS(ZSTD_d_windowLogMax, value);
	dctx->maxWindowSize = ((size_t)1) << value;
	return 0;
	case ZSTD_d_format:
	CHECK_DBOUNDS(ZSTD_d_format, value);
	dctx->format = (ZSTD_format_e)value;
	return 0;
	case ZSTD_d_stableOutBuffer:
	CHECK_DBOUNDS(ZSTD_d_stableOutBuffer, value);
	dctx->outBufferMode = (ZSTD_outBufferMode_e)value;
	return 0;
	default:;
	}
	RETURN_ERROR(parameter_unsupported, "");
	}

	size_t ZSTD_DCtx_reset(ZSTD_DCtx* dctx, ZSTD_ResetDirective reset)
	{
	if ( (reset == ZSTD_reset_session_only)
	\|\| (reset == ZSTD_reset_session_and_parameters) ) {
	dctx->streamStage = zdss_init;
	dctx->noForwardProgress = 0;
	}
	if ( (reset == ZSTD_reset_parameters)
	\|\| (reset == ZSTD_reset_session_and_parameters) ) {
	RETURN_ERROR_IF(dctx->streamStage != zdss_init, stage_wrong, "");
	ZSTD_clearDict(dctx);
	dctx->format = ZSTD_f_zstd1;
	dctx->maxWindowSize = ZSTD_MAXWINDOWSIZE_DEFAULT;
	}
	return 0;
	}


	size_t ZSTD_sizeof_DStream(const ZSTD_DStream* dctx)
	{
	return ZSTD_sizeof_DCtx(dctx);
	}

	size_t ZSTD_decodingBufferSize_min(unsigned long long windowSize, unsigned long long frameContentSize)
	{
	size_t const blockSize = (size_t) MIN(windowSize, ZSTD_BLOCKSIZE_MAX);
	unsigned long long const neededRBSize = windowSize + blockSize + (WILDCOPY_OVERLENGTH * 2);
	unsigned long long const neededSize = MIN(frameContentSize, neededRBSize);
	size_t const minRBSize = (size_t) neededSize;
	RETURN_ERROR_IF((unsigned long long)minRBSize != neededSize,
	frameParameter_windowTooLarge, "");
	return minRBSize;
	}

	size_t ZSTD_estimateDStreamSize(size_t windowSize)
	{
	size_t const blockSize = MIN(windowSize, ZSTD_BLOCKSIZE_MAX);
	size_t const inBuffSize = blockSize; /* no block can be larger */
	size_t const outBuffSize = ZSTD_decodingBufferSize_min(windowSize, ZSTD_CONTENTSIZE_UNKNOWN);
	return ZSTD_estimateDCtxSize() + inBuffSize + outBuffSize;
	}

	size_t ZSTD_estimateDStreamSize_fromFrame(const void* src, size_t srcSize)
	{
	U32 const windowSizeMax = 1U << ZSTD_WINDOWLOG_MAX; /* note : should be user-selectable, but requires an additional parameter (or a dctx) */
	ZSTD_frameHeader zfh;
	size_t const err = ZSTD_getFrameHeader(&zfh, src, srcSize);
	if (ZSTD_isError(err)) return err;
	RETURN_ERROR_IF(err>0, srcSize_wrong, "");
	RETURN_ERROR_IF(zfh.windowSize > windowSizeMax,
	frameParameter_windowTooLarge, "");
	return ZSTD_estimateDStreamSize((size_t)zfh.windowSize);
	}


	/* *** Decompression *** */

	static int ZSTD_DCtx_isOverflow(ZSTD_DStream* zds, size_t const neededInBuffSize, size_t const neededOutBuffSize)
	{
	return (zds->inBuffSize + zds->outBuffSize) >= (neededInBuffSize + neededOutBuffSize) * ZSTD_WORKSPACETOOLARGE_FACTOR;
	}

	static void ZSTD_DCtx_updateOversizedDuration(ZSTD_DStream* zds, size_t const neededInBuffSize, size_t const neededOutBuffSize)
	{
	if (ZSTD_DCtx_isOverflow(zds, neededInBuffSize, neededOutBuffSize))
	zds->oversizedDuration++;
	else
	zds->oversizedDuration = 0;
	}

	static int ZSTD_DCtx_isOversizedTooLong(ZSTD_DStream* zds)
	{
	return zds->oversizedDuration >= ZSTD_WORKSPACETOOLARGE_MAXDURATION;
	}

	/* Checks that the output buffer hasn't changed if ZSTD_obm_stable is used. */
	static size_t ZSTD_checkOutBuffer(ZSTD_DStream const* zds, ZSTD_outBuffer const* output)
	{
	ZSTD_outBuffer const expect = zds->expectedOutBuffer;
	/* No requirement when ZSTD_obm_stable is not enabled. */
	if (zds->outBufferMode != ZSTD_obm_stable)
	return 0;
	/* Any buffer is allowed in zdss_init, this must be the same for every other call until
	* the context is reset.
	*/
	if (zds->streamStage == zdss_init)
	return 0;
	/* The buffer must match our expectation exactly. */
	if (expect.dst == output->dst && expect.pos == output->pos && expect.size == output->size)
	return 0;
	RETURN_ERROR(dstBuffer_wrong, "ZSTD_obm_stable enabled but output differs!");
	}

	/* Calls ZSTD_decompressContinue() with the right parameters for ZSTD_decompressStream()
	* and updates the stage and the output buffer state. This call is extracted so it can be
	* used both when reading directly from the ZSTD_inBuffer, and in buffered input mode.
	* NOTE: You must break after calling this function since the streamStage is modified.
	*/
	static size_t ZSTD_decompressContinueStream(
	ZSTD_DStream* zds, char** op, char* oend,
	void const* src, size_t srcSize) {
	int const isSkipFrame = ZSTD_isSkipFrame(zds);
	if (zds->outBufferMode == ZSTD_obm_buffered) {
	size_t const dstSize = isSkipFrame ? 0 : zds->outBuffSize - zds->outStart;
	size_t const decodedSize = ZSTD_decompressContinue(zds,
	zds->outBuff + zds->outStart, dstSize, src, srcSize);
	FORWARD_IF_ERROR(decodedSize, "");
	if (!decodedSize && !isSkipFrame) {
	zds->streamStage = zdss_read;
	} else {
	zds->outEnd = zds->outStart + decodedSize;
	zds->streamStage = zdss_flush;
	}
	} else {
	/* Write directly into the output buffer */
	size_t const dstSize = isSkipFrame ? 0 : oend - *op;
	size_t const decodedSize = ZSTD_decompressContinue(zds, *op, dstSize, src, srcSize);
	FORWARD_IF_ERROR(decodedSize, "");
	*op += decodedSize;
	/* Flushing is not needed. */
	zds->streamStage = zdss_read;
	assert(*op <= oend);
	assert(zds->outBufferMode == ZSTD_obm_stable);
	}
	return 0;
	}

	size_t ZSTD_decompressStream(ZSTD_DStream* zds, ZSTD_outBuffer* output, ZSTD_inBuffer* input)
	{
	const char* const src = (const char*)input->src;
	const char* const istart = input->pos != 0 ? src + input->pos : src;
	const char* const iend = input->size != 0 ? src + input->size : src;
	const char* ip = istart;
	char* const dst = (char*)output->dst;
	char* const ostart = output->pos != 0 ? dst + output->pos : dst;
	char* const oend = output->size != 0 ? dst + output->size : dst;
	char* op = ostart;
	U32 someMoreWork = 1;

	DEBUGLOG(5, "ZSTD_decompressStream");
	RETURN_ERROR_IF(
	input->pos > input->size,
	srcSize_wrong,
	"forbidden. in: pos: %u vs size: %u",
	(U32)input->pos, (U32)input->size);
	RETURN_ERROR_IF(
	output->pos > output->size,
	dstSize_tooSmall,
	"forbidden. out: pos: %u vs size: %u",
	(U32)output->pos, (U32)output->size);
	DEBUGLOG(5, "input size : %u", (U32)(input->size - input->pos));
	FORWARD_IF_ERROR(ZSTD_checkOutBuffer(zds, output), "");

	while (someMoreWork) {
	switch(zds->streamStage)
	{
	case zdss_init :
	DEBUGLOG(5, "stage zdss_init => transparent reset ");
	zds->streamStage = zdss_loadHeader;
	zds->lhSize = zds->inPos = zds->outStart = zds->outEnd = 0;
	zds->legacyVersion = 0;
	zds->hostageByte = 0;
	zds->expectedOutBuffer = *output;
	/* fall-through */

	case zdss_loadHeader :
	DEBUGLOG(5, "stage zdss_loadHeader (srcSize : %u)", (U32)(iend - ip));
	#if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT>=1)
	if (zds->legacyVersion) {
	RETURN_ERROR_IF(zds->staticSize, memory_allocation,
	"legacy support is incompatible with static dctx");
	{ size_t const hint = ZSTD_decompressLegacyStream(zds->legacyContext, zds->legacyVersion, output, input);
	if (hint==0) zds->streamStage = zdss_init;
	return hint;
	} }
	#endif
	{ size_t const hSize = ZSTD_getFrameHeader_advanced(&zds->fParams, zds->headerBuffer, zds->lhSize, zds->format);
	DEBUGLOG(5, "header size : %u", (U32)hSize);
	if (ZSTD_isError(hSize)) {
	#if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT>=1)
	U32 const legacyVersion = ZSTD_isLegacy(istart, iend-istart);
	if (legacyVersion) {
	ZSTD_DDict const* const ddict = ZSTD_getDDict(zds);
	const void* const dict = ddict ? ZSTD_DDict_dictContent(ddict) : NULL;
	size_t const dictSize = ddict ? ZSTD_DDict_dictSize(ddict) : 0;
	DEBUGLOG(5, "ZSTD_decompressStream: detected legacy version v0.%u", legacyVersion);
	RETURN_ERROR_IF(zds->staticSize, memory_allocation,
	"legacy support is incompatible with static dctx");
	FORWARD_IF_ERROR(ZSTD_initLegacyStream(&zds->legacyContext,
	zds->previousLegacyVersion, legacyVersion,
	dict, dictSize), "");
	zds->legacyVersion = zds->previousLegacyVersion = legacyVersion;
	{ size_t const hint = ZSTD_decompressLegacyStream(zds->legacyContext, legacyVersion, output, input);
	if (hint==0) zds->streamStage = zdss_init; /* or stay in stage zdss_loadHeader */
	return hint;
	} }
	#endif
	return hSize; /* error */
	}
	if (hSize != 0) { /* need more input */
	size_t const toLoad = hSize - zds->lhSize; /* if hSize!=0, hSize > zds->lhSize */
	size_t const remainingInput = (size_t)(iend-ip);
	assert(iend >= ip);
	if (toLoad > remainingInput) { /* not enough input to load full header */
	if (remainingInput > 0) {
	memcpy(zds->headerBuffer + zds->lhSize, ip, remainingInput);
	zds->lhSize += remainingInput;
	}
	input->pos = input->size;
	return (MAX((size_t)ZSTD_FRAMEHEADERSIZE_MIN(zds->format), hSize) - zds->lhSize) + ZSTD_blockHeaderSize; /* remaining header bytes + next block header */
	}
	assert(ip != NULL);
	memcpy(zds->headerBuffer + zds->lhSize, ip, toLoad); zds->lhSize = hSize; ip += toLoad;
	break;
	} }

	/* check for single-pass mode opportunity */
	if (zds->fParams.frameContentSize != ZSTD_CONTENTSIZE_UNKNOWN
	&& zds->fParams.frameType != ZSTD_skippableFrame
	&& (U64)(size_t)(oend-op) >= zds->fParams.frameContentSize) {
	size_t const cSize = ZSTD_findFrameCompressedSize(istart, iend-istart);
	if (cSize <= (size_t)(iend-istart)) {
	/* shortcut : using single-pass mode */
	size_t const decompressedSize = ZSTD_decompress_usingDDict(zds, op, oend-op, istart, cSize, ZSTD_getDDict(zds));
	if (ZSTD_isError(decompressedSize)) return decompressedSize;
	DEBUGLOG(4, "shortcut to single-pass ZSTD_decompress_usingDDict()")
	ip = istart + cSize;
	op += decompressedSize;
	zds->expected = 0;
	zds->streamStage = zdss_init;
	someMoreWork = 0;
	break;
	} }

	/* Check output buffer is large enough for ZSTD_odm_stable. */
	if (zds->outBufferMode == ZSTD_obm_stable
	&& zds->fParams.frameType != ZSTD_skippableFrame
	&& zds->fParams.frameContentSize != ZSTD_CONTENTSIZE_UNKNOWN
	&& (U64)(size_t)(oend-op) < zds->fParams.frameContentSize) {
	RETURN_ERROR(dstSize_tooSmall, "ZSTD_obm_stable passed but ZSTD_outBuffer is too small");
	}

	/* Consume header (see ZSTDds_decodeFrameHeader) */
	DEBUGLOG(4, "Consume header");
	FORWARD_IF_ERROR(ZSTD_decompressBegin_usingDDict(zds, ZSTD_getDDict(zds)), "");

	if ((MEM_readLE32(zds->headerBuffer) & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) { /* skippable frame */
	zds->expected = MEM_readLE32(zds->headerBuffer + ZSTD_FRAMEIDSIZE);
	zds->stage = ZSTDds_skipFrame;
	} else {
	FORWARD_IF_ERROR(ZSTD_decodeFrameHeader(zds, zds->headerBuffer, zds->lhSize), "");
	zds->expected = ZSTD_blockHeaderSize;
	zds->stage = ZSTDds_decodeBlockHeader;
	}

	/* control buffer memory usage */
	DEBUGLOG(4, "Control max memory usage (%u KB <= max %u KB)",
	(U32)(zds->fParams.windowSize >>10),
	(U32)(zds->maxWindowSize >> 10) );
	zds->fParams.windowSize = MAX(zds->fParams.windowSize, 1U << ZSTD_WINDOWLOG_ABSOLUTEMIN);
	RETURN_ERROR_IF(zds->fParams.windowSize > zds->maxWindowSize,
	frameParameter_windowTooLarge, "");

	/* Adapt buffer sizes to frame header instructions */
	{ size_t const neededInBuffSize = MAX(zds->fParams.blockSizeMax, 4 /* frame checksum */);
	size_t const neededOutBuffSize = zds->outBufferMode == ZSTD_obm_buffered
	? ZSTD_decodingBufferSize_min(zds->fParams.windowSize, zds->fParams.frameContentSize)
	: 0;

	ZSTD_DCtx_updateOversizedDuration(zds, neededInBuffSize, neededOutBuffSize);

	{ int const tooSmall = (zds->inBuffSize < neededInBuffSize) \|\| (zds->outBuffSize < neededOutBuffSize);
	int const tooLarge = ZSTD_DCtx_isOversizedTooLong(zds);

	if (tooSmall \|\| tooLarge) {
	size_t const bufferSize = neededInBuffSize + neededOutBuffSize;
	DEBUGLOG(4, "inBuff : from %u to %u",
	(U32)zds->inBuffSize, (U32)neededInBuffSize);
	DEBUGLOG(4, "outBuff : from %u to %u",
	(U32)zds->outBuffSize, (U32)neededOutBuffSize);
	if (zds->staticSize) { /* static DCtx */
	DEBUGLOG(4, "staticSize : %u", (U32)zds->staticSize);
	assert(zds->staticSize >= sizeof(ZSTD_DCtx)); /* controlled at init */
	RETURN_ERROR_IF(
	bufferSize > zds->staticSize - sizeof(ZSTD_DCtx),
	memory_allocation, "");
	} else {
	ZSTD_free(zds->inBuff, zds->customMem);
	zds->inBuffSize = 0;
	zds->outBuffSize = 0;
	zds->inBuff = (char*)ZSTD_malloc(bufferSize, zds->customMem);
	RETURN_ERROR_IF(zds->inBuff == NULL, memory_allocation, "");
	}
	zds->inBuffSize = neededInBuffSize;
	zds->outBuff = zds->inBuff + zds->inBuffSize;
	zds->outBuffSize = neededOutBuffSize;
	} } }
	zds->streamStage = zdss_read;
	/* fall-through */

	case zdss_read:
	DEBUGLOG(5, "stage zdss_read");
	{ size_t const neededInSize = ZSTD_nextSrcSizeToDecompressWithInputSize(zds, iend - ip);
	DEBUGLOG(5, "neededInSize = %u", (U32)neededInSize);
	if (neededInSize==0) { /* end of frame */
	zds->streamStage = zdss_init;
	someMoreWork = 0;
	break;
	}
	if ((size_t)(iend-ip) >= neededInSize) { /* decode directly from src */
	FORWARD_IF_ERROR(ZSTD_decompressContinueStream(zds, &op, oend, ip, neededInSize), "");
	ip += neededInSize;
	/* Function modifies the stage so we must break */
	break;
	} }
	if (ip==iend) { someMoreWork = 0; break; } /* no more input */
	zds->streamStage = zdss_load;
	/* fall-through */

	case zdss_load:
	{ size_t const neededInSize = ZSTD_nextSrcSizeToDecompress(zds);
	size_t const toLoad = neededInSize - zds->inPos;
	int const isSkipFrame = ZSTD_isSkipFrame(zds);
	size_t loadedSize;
	/* At this point we shouldn't be decompressing a block that we can stream. */
	assert(neededInSize == ZSTD_nextSrcSizeToDecompressWithInputSize(zds, iend - ip));
	if (isSkipFrame) {
	loadedSize = MIN(toLoad, (size_t)(iend-ip));
	} else {
	RETURN_ERROR_IF(toLoad > zds->inBuffSize - zds->inPos,
	corruption_detected,
	"should never happen");
	loadedSize = ZSTD_limitCopy(zds->inBuff + zds->inPos, toLoad, ip, iend-ip);
	}
	ip += loadedSize;
	zds->inPos += loadedSize;
	if (loadedSize < toLoad) { someMoreWork = 0; break; } /* not enough input, wait for more */

	/* decode loaded input */
	zds->inPos = 0; /* input is consumed */
	FORWARD_IF_ERROR(ZSTD_decompressContinueStream(zds, &op, oend, zds->inBuff, neededInSize), "");
	/* Function modifies the stage so we must break */
	break;
	}
	case zdss_flush:
	{ size_t const toFlushSize = zds->outEnd - zds->outStart;
	size_t const flushedSize = ZSTD_limitCopy(op, oend-op, zds->outBuff + zds->outStart, toFlushSize);
	op += flushedSize;
	zds->outStart += flushedSize;
	if (flushedSize == toFlushSize) { /* flush completed */
	zds->streamStage = zdss_read;
	if ( (zds->outBuffSize < zds->fParams.frameContentSize)
	&& (zds->outStart + zds->fParams.blockSizeMax > zds->outBuffSize) ) {
	DEBUGLOG(5, "restart filling outBuff from beginning (left:%i, needed:%u)",
	(int)(zds->outBuffSize - zds->outStart),
	(U32)zds->fParams.blockSizeMax);
	zds->outStart = zds->outEnd = 0;
	}
	break;
	} }
	/* cannot complete flush */
	someMoreWork = 0;
	break;

	default:
	assert(0); /* impossible */
	RETURN_ERROR(GENERIC, "impossible to reach"); /* some compiler require default to do something */
	} }

	/* result */
	input->pos = (size_t)(ip - (const char*)(input->src));
	output->pos = (size_t)(op - (char*)(output->dst));

	/* Update the expected output buffer for ZSTD_obm_stable. */
	zds->expectedOutBuffer = *output;

	if ((ip==istart) && (op==ostart)) { /* no forward progress */
	zds->noForwardProgress ++;
	if (zds->noForwardProgress >= ZSTD_NO_FORWARD_PROGRESS_MAX) {
	RETURN_ERROR_IF(op==oend, dstSize_tooSmall, "");
	RETURN_ERROR_IF(ip==iend, srcSize_wrong, "");
	assert(0);
	}
	} else {
	zds->noForwardProgress = 0;
	}
	{ size_t nextSrcSizeHint = ZSTD_nextSrcSizeToDecompress(zds);
	if (!nextSrcSizeHint) { /* frame fully decoded */
	if (zds->outEnd == zds->outStart) { /* output fully flushed */
	if (zds->hostageByte) {
	if (input->pos >= input->size) {
	/* can't release hostage (not present) */
	zds->streamStage = zdss_read;
	return 1;
	}
	input->pos++; /* release hostage */
	} /* zds->hostageByte */
	return 0;
	} /* zds->outEnd == zds->outStart */
	if (!zds->hostageByte) { /* output not fully flushed; keep last byte as hostage; will be released when all output is flushed */
	input->pos--; /* note : pos > 0, otherwise, impossible to finish reading last block */
	zds->hostageByte=1;
	}
	return 1;
	} /* nextSrcSizeHint==0 */
	nextSrcSizeHint += ZSTD_blockHeaderSize * (ZSTD_nextInputType(zds) == ZSTDnit_block); /* preload header of next block */
	assert(zds->inPos <= nextSrcSizeHint);
	nextSrcSizeHint -= zds->inPos; /* part already loaded*/
	return nextSrcSizeHint;
	}
	}

	size_t ZSTD_decompressStream_simpleArgs (
	ZSTD_DCtx* dctx,
	void* dst, size_t dstCapacity, size_t* dstPos,
	const void* src, size_t srcSize, size_t* srcPos)
	{
	ZSTD_outBuffer output = { dst, dstCapacity, *dstPos };
	ZSTD_inBuffer input = { src, srcSize, *srcPos };
	/* ZSTD_compress_generic() will check validity of dstPos and srcPos */
	size_t const cErr = ZSTD_decompressStream(dctx, &output, &input);
	*dstPos = output.pos;
	*srcPos = input.pos;
	return cErr;
	}
	/** ended inlining decompress/zstd_decompress.c **/
	/** start inlining decompress/zstd_decompress_block.c **/
	/*
	* Copyright (c) 2016-2020, Yann Collet, Facebook, Inc.
	* All rights reserved.
	*
	* This source code is licensed under both the BSD-style license (found in the
	* LICENSE file in the root directory of this source tree) and the GPLv2 (found
	* in the COPYING file in the root directory of this source tree).
	* You may select, at your option, one of the above-listed licenses.
	*/

	/* zstd_decompress_block :
	* this module takes care of decompressing _compressed_ block */

	/-******************************************************
	* Dependencies
	*********************************************************/
	#include <string.h> /* memcpy, memmove, memset */
	/** skipping file: ../common/compiler.h **/
	/** skipping file: ../common/cpu.h **/
	/** skipping file: ../common/mem.h **/
	#define FSE_STATIC_LINKING_ONLY
	/** skipping file: ../common/fse.h **/
	#define HUF_STATIC_LINKING_ONLY
	/** skipping file: ../common/huf.h **/
	/** skipping file: ../common/zstd_internal.h **/
	/** skipping file: zstd_decompress_internal.h **/
	/** skipping file: zstd_ddict.h **/
	/** skipping file: zstd_decompress_block.h **/

	/_******************************************************
	* Macros
	**********************************************************/

	/* These two optional macros force the use one way or another of the two
	* ZSTD_decompressSequences implementations. You can't force in both directions
	* at the same time.
	*/
	#if defined(ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT) && \
	defined(ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG)
	#error "Cannot force the use of the short and the long ZSTD_decompressSequences variants!"
	#endif


	/_******************************************************
	* Memory operations
	**********************************************************/
	static void ZSTD_copy4(void* dst, const void* src) { memcpy(dst, src, 4); }


	/-************************************************************
	* Block decoding
	***************************************************************/

	/*! ZSTD_getcBlockSize() :
	* Provides the size of compressed block from block header `src` */
	size_t ZSTD_getcBlockSize(const void* src, size_t srcSize,
	blockProperties_t* bpPtr)
	{
	RETURN_ERROR_IF(srcSize < ZSTD_blockHeaderSize, srcSize_wrong, "");

	{ U32 const cBlockHeader = MEM_readLE24(src);
	U32 const cSize = cBlockHeader >> 3;
	bpPtr->lastBlock = cBlockHeader & 1;
	bpPtr->blockType = (blockType_e)((cBlockHeader >> 1) & 3);
	bpPtr->origSize = cSize; /* only useful for RLE */
	if (bpPtr->blockType == bt_rle) return 1;
	RETURN_ERROR_IF(bpPtr->blockType == bt_reserved, corruption_detected, "");
	return cSize;
	}
	}


	/* Hidden declaration for fullbench */
	size_t ZSTD_decodeLiteralsBlock(ZSTD_DCtx* dctx,
	const void* src, size_t srcSize);
	/*! ZSTD_decodeLiteralsBlock() :
	* @return : nb of bytes read from src (< srcSize )
	* note : symbol not declared but exposed for fullbench */
	size_t ZSTD_decodeLiteralsBlock(ZSTD_DCtx* dctx,
	const void* src, size_t srcSize) /* note : srcSize < BLOCKSIZE */
	{
	DEBUGLOG(5, "ZSTD_decodeLiteralsBlock");
	RETURN_ERROR_IF(srcSize < MIN_CBLOCK_SIZE, corruption_detected, "");

	{ const BYTE* const istart = (const BYTE*) src;
	symbolEncodingType_e const litEncType = (symbolEncodingType_e)(istart[0] & 3);

	switch(litEncType)
	{
	case set_repeat:
	DEBUGLOG(5, "set_repeat flag : re-using stats from previous compressed literals block");
	RETURN_ERROR_IF(dctx->litEntropy==0, dictionary_corrupted, "");
	/* fall-through */

	case set_compressed:
	RETURN_ERROR_IF(srcSize < 5, corruption_detected, "srcSize >= MIN_CBLOCK_SIZE == 3; here we need up to 5 for case 3");
	{ size_t lhSize, litSize, litCSize;
	U32 singleStream=0;
	U32 const lhlCode = (istart[0] >> 2) & 3;
	U32 const lhc = MEM_readLE32(istart);
	size_t hufSuccess;
	switch(lhlCode)
	{
	case 0: case 1: default: /* note : default is impossible, since lhlCode into [0..3] */
	/* 2 - 2 - 10 - 10 */
	singleStream = !lhlCode;
	lhSize = 3;
	litSize = (lhc >> 4) & 0x3FF;
	litCSize = (lhc >> 14) & 0x3FF;
	break;
	case 2:
	/* 2 - 2 - 14 - 14 */
	lhSize = 4;
	litSize = (lhc >> 4) & 0x3FFF;
	litCSize = lhc >> 18;
	break;
	case 3:
	/* 2 - 2 - 18 - 18 */
	lhSize = 5;
	litSize = (lhc >> 4) & 0x3FFFF;
	litCSize = (lhc >> 22) + ((size_t)istart[4] << 10);
	break;
	}
	RETURN_ERROR_IF(litSize > ZSTD_BLOCKSIZE_MAX, corruption_detected, "");
	RETURN_ERROR_IF(litCSize + lhSize > srcSize, corruption_detected, "");

	/* prefetch huffman table if cold */
	if (dctx->ddictIsCold && (litSize > 768 /* heuristic */)) {
	PREFETCH_AREA(dctx->HUFptr, sizeof(dctx->entropy.hufTable));
	}

	if (litEncType==set_repeat) {
	if (singleStream) {
	hufSuccess = HUF_decompress1X_usingDTable_bmi2(
	dctx->litBuffer, litSize, istart+lhSize, litCSize,
	dctx->HUFptr, dctx->bmi2);
	} else {
	hufSuccess = HUF_decompress4X_usingDTable_bmi2(
	dctx->litBuffer, litSize, istart+lhSize, litCSize,
	dctx->HUFptr, dctx->bmi2);
	}
	} else {
	if (singleStream) {
	#if defined(HUF_FORCE_DECOMPRESS_X2)
	hufSuccess = HUF_decompress1X_DCtx_wksp(
	dctx->entropy.hufTable, dctx->litBuffer, litSize,
	istart+lhSize, litCSize, dctx->workspace,
	sizeof(dctx->workspace));
	#else
	hufSuccess = HUF_decompress1X1_DCtx_wksp_bmi2(
	dctx->entropy.hufTable, dctx->litBuffer, litSize,
	istart+lhSize, litCSize, dctx->workspace,
	sizeof(dctx->workspace), dctx->bmi2);
	#endif
	} else {
	hufSuccess = HUF_decompress4X_hufOnly_wksp_bmi2(
	dctx->entropy.hufTable, dctx->litBuffer, litSize,
	istart+lhSize, litCSize, dctx->workspace,
	sizeof(dctx->workspace), dctx->bmi2);
	}
	}

	RETURN_ERROR_IF(HUF_isError(hufSuccess), corruption_detected, "");

	dctx->litPtr = dctx->litBuffer;
	dctx->litSize = litSize;
	dctx->litEntropy = 1;
	if (litEncType==set_compressed) dctx->HUFptr = dctx->entropy.hufTable;
	memset(dctx->litBuffer + dctx->litSize, 0, WILDCOPY_OVERLENGTH);
	return litCSize + lhSize;
	}

	case set_basic:
	{ size_t litSize, lhSize;
	U32 const lhlCode = ((istart[0]) >> 2) & 3;
	switch(lhlCode)
	{
	case 0: case 2: default: /* note : default is impossible, since lhlCode into [0..3] */
	lhSize = 1;
	litSize = istart[0] >> 3;
	break;
	case 1:
	lhSize = 2;
	litSize = MEM_readLE16(istart) >> 4;
	break;
	case 3:
	lhSize = 3;
	litSize = MEM_readLE24(istart) >> 4;
	break;
	}

	if (lhSize+litSize+WILDCOPY_OVERLENGTH > srcSize) { /* risk reading beyond src buffer with wildcopy */
	RETURN_ERROR_IF(litSize+lhSize > srcSize, corruption_detected, "");
	memcpy(dctx->litBuffer, istart+lhSize, litSize);
	dctx->litPtr = dctx->litBuffer;
	dctx->litSize = litSize;
	memset(dctx->litBuffer + dctx->litSize, 0, WILDCOPY_OVERLENGTH);
	return lhSize+litSize;
	}
	/* direct reference into compressed stream */
	dctx->litPtr = istart+lhSize;
	dctx->litSize = litSize;
	return lhSize+litSize;
	}

	case set_rle:
	{ U32 const lhlCode = ((istart[0]) >> 2) & 3;
	size_t litSize, lhSize;
	switch(lhlCode)
	{
	case 0: case 2: default: /* note : default is impossible, since lhlCode into [0..3] */
	lhSize = 1;
	litSize = istart[0] >> 3;
	break;
	case 1:
	lhSize = 2;
	litSize = MEM_readLE16(istart) >> 4;
	break;
	case 3:
	lhSize = 3;
	litSize = MEM_readLE24(istart) >> 4;
	RETURN_ERROR_IF(srcSize<4, corruption_detected, "srcSize >= MIN_CBLOCK_SIZE == 3; here we need lhSize+1 = 4");
	break;
	}
	RETURN_ERROR_IF(litSize > ZSTD_BLOCKSIZE_MAX, corruption_detected, "");
	memset(dctx->litBuffer, istart[lhSize], litSize + WILDCOPY_OVERLENGTH);
	dctx->litPtr = dctx->litBuffer;
	dctx->litSize = litSize;
	return lhSize+1;
	}
	default:
	RETURN_ERROR(corruption_detected, "impossible");
	}
	}
	}

	/* Default FSE distribution tables.
	* These are pre-calculated FSE decoding tables using default distributions as defined in specification :
	* https://github.com/facebook/zstd/blob/master/doc/zstd_compression_format.md#default-distributions
	* They were generated programmatically with following method :
	* - start from default distributions, present in /lib/common/zstd_internal.h
	* - generate tables normally, using ZSTD_buildFSETable()
	* - printout the content of tables
	* - pretify output, report below, test with fuzzer to ensure it's correct */

	/* Default FSE distribution table for Literal Lengths */
	static const ZSTD_seqSymbol LL_defaultDTable[(1<<LL_DEFAULTNORMLOG)+1] = {
	{ 1, 1, 1, LL_DEFAULTNORMLOG}, /* header : fastMode, tableLog */
	/* nextState, nbAddBits, nbBits, baseVal */
	{ 0, 0, 4, 0}, { 16, 0, 4, 0},
	{ 32, 0, 5, 1}, { 0, 0, 5, 3},
	{ 0, 0, 5, 4}, { 0, 0, 5, 6},
	{ 0, 0, 5, 7}, { 0, 0, 5, 9},
	{ 0, 0, 5, 10}, { 0, 0, 5, 12},
	{ 0, 0, 6, 14}, { 0, 1, 5, 16},
	{ 0, 1, 5, 20}, { 0, 1, 5, 22},
	{ 0, 2, 5, 28}, { 0, 3, 5, 32},
	{ 0, 4, 5, 48}, { 32, 6, 5, 64},
	{ 0, 7, 5, 128}, { 0, 8, 6, 256},
	{ 0, 10, 6, 1024}, { 0, 12, 6, 4096},
	{ 32, 0, 4, 0}, { 0, 0, 4, 1},
	{ 0, 0, 5, 2}, { 32, 0, 5, 4},
	{ 0, 0, 5, 5}, { 32, 0, 5, 7},
	{ 0, 0, 5, 8}, { 32, 0, 5, 10},
	{ 0, 0, 5, 11}, { 0, 0, 6, 13},
	{ 32, 1, 5, 16}, { 0, 1, 5, 18},
	{ 32, 1, 5, 22}, { 0, 2, 5, 24},
	{ 32, 3, 5, 32}, { 0, 3, 5, 40},
	{ 0, 6, 4, 64}, { 16, 6, 4, 64},
	{ 32, 7, 5, 128}, { 0, 9, 6, 512},
	{ 0, 11, 6, 2048}, { 48, 0, 4, 0},
	{ 16, 0, 4, 1}, { 32, 0, 5, 2},
	{ 32, 0, 5, 3}, { 32, 0, 5, 5},
	{ 32, 0, 5, 6}, { 32, 0, 5, 8},
	{ 32, 0, 5, 9}, { 32, 0, 5, 11},
	{ 32, 0, 5, 12}, { 0, 0, 6, 15},
	{ 32, 1, 5, 18}, { 32, 1, 5, 20},
	{ 32, 2, 5, 24}, { 32, 2, 5, 28},
	{ 32, 3, 5, 40}, { 32, 4, 5, 48},
	{ 0, 16, 6,65536}, { 0, 15, 6,32768},
	{ 0, 14, 6,16384}, { 0, 13, 6, 8192},
	}; /* LL_defaultDTable */

	/* Default FSE distribution table for Offset Codes */
	static const ZSTD_seqSymbol OF_defaultDTable[(1<<OF_DEFAULTNORMLOG)+1] = {
	{ 1, 1, 1, OF_DEFAULTNORMLOG}, /* header : fastMode, tableLog */
	/* nextState, nbAddBits, nbBits, baseVal */
	{ 0, 0, 5, 0}, { 0, 6, 4, 61},
	{ 0, 9, 5, 509}, { 0, 15, 5,32765},
	{ 0, 21, 5,2097149}, { 0, 3, 5, 5},
	{ 0, 7, 4, 125}, { 0, 12, 5, 4093},
	{ 0, 18, 5,262141}, { 0, 23, 5,8388605},
	{ 0, 5, 5, 29}, { 0, 8, 4, 253},
	{ 0, 14, 5,16381}, { 0, 20, 5,1048573},
	{ 0, 2, 5, 1}, { 16, 7, 4, 125},
	{ 0, 11, 5, 2045}, { 0, 17, 5,131069},
	{ 0, 22, 5,4194301}, { 0, 4, 5, 13},
	{ 16, 8, 4, 253}, { 0, 13, 5, 8189},
	{ 0, 19, 5,524285}, { 0, 1, 5, 1},
	{ 16, 6, 4, 61}, { 0, 10, 5, 1021},
	{ 0, 16, 5,65533}, { 0, 28, 5,268435453},
	{ 0, 27, 5,134217725}, { 0, 26, 5,67108861},
	{ 0, 25, 5,33554429}, { 0, 24, 5,16777213},
	}; /* OF_defaultDTable */


	/* Default FSE distribution table for Match Lengths */
	static const ZSTD_seqSymbol ML_defaultDTable[(1<<ML_DEFAULTNORMLOG)+1] = {
	{ 1, 1, 1, ML_DEFAULTNORMLOG}, /* header : fastMode, tableLog */
	/* nextState, nbAddBits, nbBits, baseVal */
	{ 0, 0, 6, 3}, { 0, 0, 4, 4},
	{ 32, 0, 5, 5}, { 0, 0, 5, 6},
	{ 0, 0, 5, 8}, { 0, 0, 5, 9},
	{ 0, 0, 5, 11}, { 0, 0, 6, 13},
	{ 0, 0, 6, 16}, { 0, 0, 6, 19},
	{ 0, 0, 6, 22}, { 0, 0, 6, 25},
	{ 0, 0, 6, 28}, { 0, 0, 6, 31},
	{ 0, 0, 6, 34}, { 0, 1, 6, 37},
	{ 0, 1, 6, 41}, { 0, 2, 6, 47},
	{ 0, 3, 6, 59}, { 0, 4, 6, 83},
	{ 0, 7, 6, 131}, { 0, 9, 6, 515},
	{ 16, 0, 4, 4}, { 0, 0, 4, 5},
	{ 32, 0, 5, 6}, { 0, 0, 5, 7},
	{ 32, 0, 5, 9}, { 0, 0, 5, 10},
	{ 0, 0, 6, 12}, { 0, 0, 6, 15},
	{ 0, 0, 6, 18}, { 0, 0, 6, 21},
	{ 0, 0, 6, 24}, { 0, 0, 6, 27},
	{ 0, 0, 6, 30}, { 0, 0, 6, 33},
	{ 0, 1, 6, 35}, { 0, 1, 6, 39},
	{ 0, 2, 6, 43}, { 0, 3, 6, 51},
	{ 0, 4, 6, 67}, { 0, 5, 6, 99},
	{ 0, 8, 6, 259}, { 32, 0, 4, 4},
	{ 48, 0, 4, 4}, { 16, 0, 4, 5},
	{ 32, 0, 5, 7}, { 32, 0, 5, 8},
	{ 32, 0, 5, 10}, { 32, 0, 5, 11},
	{ 0, 0, 6, 14}, { 0, 0, 6, 17},
	{ 0, 0, 6, 20}, { 0, 0, 6, 23},
	{ 0, 0, 6, 26}, { 0, 0, 6, 29},
	{ 0, 0, 6, 32}, { 0, 16, 6,65539},
	{ 0, 15, 6,32771}, { 0, 14, 6,16387},
	{ 0, 13, 6, 8195}, { 0, 12, 6, 4099},
	{ 0, 11, 6, 2051}, { 0, 10, 6, 1027},
	}; /* ML_defaultDTable */


	static void ZSTD_buildSeqTable_rle(ZSTD_seqSymbol* dt, U32 baseValue, U32 nbAddBits)
	{
	void* ptr = dt;
	ZSTD_seqSymbol_header* const DTableH = (ZSTD_seqSymbol_header*)ptr;
	ZSTD_seqSymbol* const cell = dt + 1;

	DTableH->tableLog = 0;
	DTableH->fastMode = 0;

	cell->nbBits = 0;
	cell->nextState = 0;
	assert(nbAddBits < 255);
	cell->nbAdditionalBits = (BYTE)nbAddBits;
	cell->baseValue = baseValue;
	}


	/* ZSTD_buildFSETable() :
	* generate FSE decoding table for one symbol (ll, ml or off)
	* cannot fail if input is valid =>
	* all inputs are presumed validated at this stage */
	void
	ZSTD_buildFSETable(ZSTD_seqSymbol* dt,
	const short* normalizedCounter, unsigned maxSymbolValue,
	const U32* baseValue, const U32* nbAdditionalBits,
	unsigned tableLog)
	{
	ZSTD_seqSymbol* const tableDecode = dt+1;
	U16 symbolNext[MaxSeq+1];

	U32 const maxSV1 = maxSymbolValue + 1;
	U32 const tableSize = 1 << tableLog;
	U32 highThreshold = tableSize-1;

	/* Sanity Checks */
	assert(maxSymbolValue <= MaxSeq);
	assert(tableLog <= MaxFSELog);

	/* Init, lay down lowprob symbols */
	{ ZSTD_seqSymbol_header DTableH;
	DTableH.tableLog = tableLog;
	DTableH.fastMode = 1;
	{ S16 const largeLimit= (S16)(1 << (tableLog-1));
	U32 s;
	for (s=0; s<maxSV1; s++) {
	if (normalizedCounter[s]==-1) {
	tableDecode[highThreshold--].baseValue = s;
	symbolNext[s] = 1;
	} else {
	if (normalizedCounter[s] >= largeLimit) DTableH.fastMode=0;
	assert(normalizedCounter[s]>=0);
	symbolNext[s] = (U16)normalizedCounter[s];
	} } }
	memcpy(dt, &DTableH, sizeof(DTableH));
	}

	/* Spread symbols */
	{ U32 const tableMask = tableSize-1;
	U32 const step = FSE_TABLESTEP(tableSize);
	U32 s, position = 0;
	for (s=0; s<maxSV1; s++) {
	int i;
	for (i=0; i<normalizedCounter[s]; i++) {
	tableDecode[position].baseValue = s;
	position = (position + step) & tableMask;
	while (position > highThreshold) position = (position + step) & tableMask; /* lowprob area */
	} }
	assert(position == 0); /* position must reach all cells once, otherwise normalizedCounter is incorrect */
	}

	/* Build Decoding table */
	{ U32 u;
	for (u=0; u<tableSize; u++) {
	U32 const symbol = tableDecode[u].baseValue;
	U32 const nextState = symbolNext[symbol]++;
	tableDecode[u].nbBits = (BYTE) (tableLog - BIT_highbit32(nextState) );
	tableDecode[u].nextState = (U16) ( (nextState << tableDecode[u].nbBits) - tableSize);
	assert(nbAdditionalBits[symbol] < 255);
	tableDecode[u].nbAdditionalBits = (BYTE)nbAdditionalBits[symbol];
	tableDecode[u].baseValue = baseValue[symbol];
	} }
	}


	/*! ZSTD_buildSeqTable() :
	* @return : nb bytes read from src,
	* or an error code if it fails */
	static size_t ZSTD_buildSeqTable(ZSTD_seqSymbol* DTableSpace, const ZSTD_seqSymbol** DTablePtr,
	symbolEncodingType_e type, unsigned max, U32 maxLog,
	const void* src, size_t srcSize,
	const U32* baseValue, const U32* nbAdditionalBits,
	const ZSTD_seqSymbol* defaultTable, U32 flagRepeatTable,
	int ddictIsCold, int nbSeq)
	{
	switch(type)
	{
	case set_rle :
	RETURN_ERROR_IF(!srcSize, srcSize_wrong, "");
	RETURN_ERROR_IF(((const BYTE)src) > max, corruption_detected, "");
	{ U32 const symbol = (const BYTE)src;
	U32 const baseline = baseValue[symbol];
	U32 const nbBits = nbAdditionalBits[symbol];
	ZSTD_buildSeqTable_rle(DTableSpace, baseline, nbBits);
	}
	*DTablePtr = DTableSpace;
	return 1;
	case set_basic :
	*DTablePtr = defaultTable;
	return 0;
	case set_repeat:
	RETURN_ERROR_IF(!flagRepeatTable, corruption_detected, "");
	/* prefetch FSE table if used */
	if (ddictIsCold && (nbSeq > 24 /* heuristic */)) {
	const void* const pStart = *DTablePtr;
	size_t const pSize = sizeof(ZSTD_seqSymbol) * (SEQSYMBOL_TABLE_SIZE(maxLog));
	PREFETCH_AREA(pStart, pSize);
	}
	return 0;
	case set_compressed :
	{ unsigned tableLog;
	S16 norm[MaxSeq+1];
	size_t const headerSize = FSE_readNCount(norm, &max, &tableLog, src, srcSize);
	RETURN_ERROR_IF(FSE_isError(headerSize), corruption_detected, "");
	RETURN_ERROR_IF(tableLog > maxLog, corruption_detected, "");
	ZSTD_buildFSETable(DTableSpace, norm, max, baseValue, nbAdditionalBits, tableLog);
	*DTablePtr = DTableSpace;
	return headerSize;
	}
	default :
	assert(0);
	RETURN_ERROR(GENERIC, "impossible");
	}
	}

	size_t ZSTD_decodeSeqHeaders(ZSTD_DCtx* dctx, int* nbSeqPtr,
	const void* src, size_t srcSize)
	{
	const BYTE* const istart = (const BYTE* const)src;
	const BYTE* const iend = istart + srcSize;
	const BYTE* ip = istart;
	int nbSeq;
	DEBUGLOG(5, "ZSTD_decodeSeqHeaders");

	/* check */
	RETURN_ERROR_IF(srcSize < MIN_SEQUENCES_SIZE, srcSize_wrong, "");

	/* SeqHead */
	nbSeq = *ip++;
	if (!nbSeq) {
	*nbSeqPtr=0;
	RETURN_ERROR_IF(srcSize != 1, srcSize_wrong, "");
	return 1;
	}
	if (nbSeq > 0x7F) {
	if (nbSeq == 0xFF) {
	RETURN_ERROR_IF(ip+2 > iend, srcSize_wrong, "");
	nbSeq = MEM_readLE16(ip) + LONGNBSEQ, ip+=2;
	} else {
	RETURN_ERROR_IF(ip >= iend, srcSize_wrong, "");
	nbSeq = ((nbSeq-0x80)<<8) + *ip++;
	}
	}
	*nbSeqPtr = nbSeq;

	/* FSE table descriptors */
	RETURN_ERROR_IF(ip+1 > iend, srcSize_wrong, ""); /* minimum possible size: 1 byte for symbol encoding types */
	{ symbolEncodingType_e const LLtype = (symbolEncodingType_e)(*ip >> 6);
	symbolEncodingType_e const OFtype = (symbolEncodingType_e)((*ip >> 4) & 3);
	symbolEncodingType_e const MLtype = (symbolEncodingType_e)((*ip >> 2) & 3);
	ip++;

	/* Build DTables */
	{ size_t const llhSize = ZSTD_buildSeqTable(dctx->entropy.LLTable, &dctx->LLTptr,
	LLtype, MaxLL, LLFSELog,
	ip, iend-ip,
	LL_base, LL_bits,
	LL_defaultDTable, dctx->fseEntropy,
	dctx->ddictIsCold, nbSeq);
	RETURN_ERROR_IF(ZSTD_isError(llhSize), corruption_detected, "ZSTD_buildSeqTable failed");
	ip += llhSize;
	}

	{ size_t const ofhSize = ZSTD_buildSeqTable(dctx->entropy.OFTable, &dctx->OFTptr,
	OFtype, MaxOff, OffFSELog,
	ip, iend-ip,
	OF_base, OF_bits,
	OF_defaultDTable, dctx->fseEntropy,
	dctx->ddictIsCold, nbSeq);
	RETURN_ERROR_IF(ZSTD_isError(ofhSize), corruption_detected, "ZSTD_buildSeqTable failed");
	ip += ofhSize;
	}

	{ size_t const mlhSize = ZSTD_buildSeqTable(dctx->entropy.MLTable, &dctx->MLTptr,
	MLtype, MaxML, MLFSELog,
	ip, iend-ip,
	ML_base, ML_bits,
	ML_defaultDTable, dctx->fseEntropy,
	dctx->ddictIsCold, nbSeq);
	RETURN_ERROR_IF(ZSTD_isError(mlhSize), corruption_detected, "ZSTD_buildSeqTable failed");
	ip += mlhSize;
	}
	}

	return ip-istart;
	}


	typedef struct {
	size_t litLength;
	size_t matchLength;
	size_t offset;
	const BYTE* match;
	} seq_t;

	typedef struct {
	size_t state;
	const ZSTD_seqSymbol* table;
	} ZSTD_fseState;

	typedef struct {
	BIT_DStream_t DStream;
	ZSTD_fseState stateLL;
	ZSTD_fseState stateOffb;
	ZSTD_fseState stateML;
	size_t prevOffset[ZSTD_REP_NUM];
	const BYTE* prefixStart;
	const BYTE* dictEnd;
	size_t pos;
	} seqState_t;

	/*! ZSTD_overlapCopy8() :
	* Copies 8 bytes from ip to op and updates op and ip where ip <= op.
	* If the offset is < 8 then the offset is spread to at least 8 bytes.
	*
	* Precondition: ip <= op
	* Postcondition: op - op >= 8
	*/
	HINT_INLINE void ZSTD_overlapCopy8(BYTE op, BYTE const ip, size_t offset) {
	assert(ip <= op);
	if (offset < 8) {
	/* close range match, overlap */
	static const U32 dec32table[] = { 0, 1, 2, 1, 4, 4, 4, 4 }; /* added */
	static const int dec64table[] = { 8, 8, 8, 7, 8, 9,10,11 }; /* subtracted */
	int const sub2 = dec64table[offset];
	(op)[0] = (ip)[0];
	(op)[1] = (ip)[1];
	(op)[2] = (ip)[2];
	(op)[3] = (ip)[3];
	*ip += dec32table[offset];
	ZSTD_copy4(op+4, ip);
	*ip -= sub2;
	} else {
	ZSTD_copy8(op, ip);
	}
	*ip += 8;
	*op += 8;
	assert(op - ip >= 8);
	}

	/*! ZSTD_safecopy() :
	* Specialized version of memcpy() that is allowed to READ up to WILDCOPY_OVERLENGTH past the input buffer
	* and write up to 16 bytes past oend_w (op >= oend_w is allowed).
	* This function is only called in the uncommon case where the sequence is near the end of the block. It
	* should be fast for a single long sequence, but can be slow for several short sequences.
	*
	* @param ovtype controls the overlap detection
	* - ZSTD_no_overlap: The source and destination are guaranteed to be at least WILDCOPY_VECLEN bytes apart.
	* - ZSTD_overlap_src_before_dst: The src and dst may overlap and may be any distance apart.
	* The src buffer must be before the dst buffer.
	*/
	static void ZSTD_safecopy(BYTE* op, BYTE* const oend_w, BYTE const* ip, ptrdiff_t length, ZSTD_overlap_e ovtype) {
	ptrdiff_t const diff = op - ip;
	BYTE* const oend = op + length;

	assert((ovtype == ZSTD_no_overlap && (diff <= -8 \|\| diff >= 8 \|\| op >= oend_w)) \|\|
	(ovtype == ZSTD_overlap_src_before_dst && diff >= 0));

	if (length < 8) {
	/* Handle short lengths. */
	while (op < oend) op++ = ip++;
	return;
	}
	if (ovtype == ZSTD_overlap_src_before_dst) {
	/* Copy 8 bytes and ensure the offset >= 8 when there can be overlap. */
	assert(length >= 8);
	ZSTD_overlapCopy8(&op, &ip, diff);
	assert(op - ip >= 8);
	assert(op <= oend);
	}

	if (oend <= oend_w) {
	/* No risk of overwrite. */
	ZSTD_wildcopy(op, ip, length, ovtype);
	return;
	}
	if (op <= oend_w) {
	/* Wildcopy until we get close to the end. */
	assert(oend > oend_w);
	ZSTD_wildcopy(op, ip, oend_w - op, ovtype);
	ip += oend_w - op;
	op = oend_w;
	}
	/* Handle the leftovers. */
	while (op < oend) op++ = ip++;
	}

	/* ZSTD_execSequenceEnd():
	* This version handles cases that are near the end of the output buffer. It requires
	* more careful checks to make sure there is no overflow. By separating out these hard
	* and unlikely cases, we can speed up the common cases.
	*
	* NOTE: This function needs to be fast for a single long sequence, but doesn't need
	* to be optimized for many small sequences, since those fall into ZSTD_execSequence().
	*/
	FORCE_NOINLINE
	size_t ZSTD_execSequenceEnd(BYTE* op,
	BYTE* const oend, seq_t sequence,
	const BYTE** litPtr, const BYTE* const litLimit,
	const BYTE* const prefixStart, const BYTE* const virtualStart, const BYTE* const dictEnd)
	{
	BYTE* const oLitEnd = op + sequence.litLength;
	size_t const sequenceLength = sequence.litLength + sequence.matchLength;
	const BYTE* const iLitEnd = *litPtr + sequence.litLength;
	const BYTE* match = oLitEnd - sequence.offset;
	BYTE* const oend_w = oend - WILDCOPY_OVERLENGTH;

	/* bounds checks : careful of address space overflow in 32-bit mode */
	RETURN_ERROR_IF(sequenceLength > (size_t)(oend - op), dstSize_tooSmall, "last match must fit within dstBuffer");
	RETURN_ERROR_IF(sequence.litLength > (size_t)(litLimit - *litPtr), corruption_detected, "try to read beyond literal buffer");
	assert(op < op + sequenceLength);
	assert(oLitEnd < op + sequenceLength);

	/* copy literals */
	ZSTD_safecopy(op, oend_w, *litPtr, sequence.litLength, ZSTD_no_overlap);
	op = oLitEnd;
	*litPtr = iLitEnd;

	/* copy Match */
	if (sequence.offset > (size_t)(oLitEnd - prefixStart)) {
	/* offset beyond prefix */
	RETURN_ERROR_IF(sequence.offset > (size_t)(oLitEnd - virtualStart), corruption_detected, "");
	match = dictEnd - (prefixStart-match);
	if (match + sequence.matchLength <= dictEnd) {
	memmove(oLitEnd, match, sequence.matchLength);
	return sequenceLength;
	}
	/* span extDict & currentPrefixSegment */
	{ size_t const length1 = dictEnd - match;
	memmove(oLitEnd, match, length1);
	op = oLitEnd + length1;
	sequence.matchLength -= length1;
	match = prefixStart;
	} }
	ZSTD_safecopy(op, oend_w, match, sequence.matchLength, ZSTD_overlap_src_before_dst);
	return sequenceLength;
	}

	HINT_INLINE
	size_t ZSTD_execSequence(BYTE* op,
	BYTE* const oend, seq_t sequence,
	const BYTE** litPtr, const BYTE* const litLimit,
	const BYTE* const prefixStart, const BYTE* const virtualStart, const BYTE* const dictEnd)
	{
	BYTE* const oLitEnd = op + sequence.litLength;
	size_t const sequenceLength = sequence.litLength + sequence.matchLength;
	BYTE* const oMatchEnd = op + sequenceLength; /* risk : address space overflow (32-bits) */
	BYTE* const oend_w = oend - WILDCOPY_OVERLENGTH; /* risk : address space underflow on oend=NULL */
	const BYTE* const iLitEnd = *litPtr + sequence.litLength;
	const BYTE* match = oLitEnd - sequence.offset;

	assert(op != NULL /* Precondition */);
	assert(oend_w < oend /* No underflow */);
	/* Handle edge cases in a slow path:
	* - Read beyond end of literals
	* - Match end is within WILDCOPY_OVERLIMIT of oend
	* - 32-bit mode and the match length overflows
	*/
	if (UNLIKELY(
	iLitEnd > litLimit \|\|
	oMatchEnd > oend_w \|\|
	(MEM_32bits() && (size_t)(oend - op) < sequenceLength + WILDCOPY_OVERLENGTH)))
	return ZSTD_execSequenceEnd(op, oend, sequence, litPtr, litLimit, prefixStart, virtualStart, dictEnd);

	/* Assumptions (everything else goes into ZSTD_execSequenceEnd()) */
	assert(op <= oLitEnd /* No overflow */);
	assert(oLitEnd < oMatchEnd /* Non-zero match & no overflow */);
	assert(oMatchEnd <= oend /* No underflow */);
	assert(iLitEnd <= litLimit /* Literal length is in bounds */);
	assert(oLitEnd <= oend_w /* Can wildcopy literals */);
	assert(oMatchEnd <= oend_w /* Can wildcopy matches */);

	/* Copy Literals:
	* Split out litLength <= 16 since it is nearly always true. +1.6% on gcc-9.
	* We likely don't need the full 32-byte wildcopy.
	*/
	assert(WILDCOPY_OVERLENGTH >= 16);
	ZSTD_copy16(op, (*litPtr));
	if (UNLIKELY(sequence.litLength > 16)) {
	ZSTD_wildcopy(op+16, (*litPtr)+16, sequence.litLength-16, ZSTD_no_overlap);
	}
	op = oLitEnd;
	litPtr = iLitEnd; / update for next sequence */

	/* Copy Match */
	if (sequence.offset > (size_t)(oLitEnd - prefixStart)) {
	/* offset beyond prefix -> go into extDict */
	RETURN_ERROR_IF(UNLIKELY(sequence.offset > (size_t)(oLitEnd - virtualStart)), corruption_detected, "");
	match = dictEnd + (match - prefixStart);
	if (match + sequence.matchLength <= dictEnd) {
	memmove(oLitEnd, match, sequence.matchLength);
	return sequenceLength;
	}
	/* span extDict & currentPrefixSegment */
	{ size_t const length1 = dictEnd - match;
	memmove(oLitEnd, match, length1);
	op = oLitEnd + length1;
	sequence.matchLength -= length1;
	match = prefixStart;
	} }
	/* Match within prefix of 1 or more bytes */
	assert(op <= oMatchEnd);
	assert(oMatchEnd <= oend_w);
	assert(match >= prefixStart);
	assert(sequence.matchLength >= 1);

	/* Nearly all offsets are >= WILDCOPY_VECLEN bytes, which means we can use wildcopy
	* without overlap checking.
	*/
	if (LIKELY(sequence.offset >= WILDCOPY_VECLEN)) {
	/* We bet on a full wildcopy for matches, since we expect matches to be
	* longer than literals (in general). In silesia, ~10% of matches are longer
	* than 16 bytes.
	*/
	ZSTD_wildcopy(op, match, (ptrdiff_t)sequence.matchLength, ZSTD_no_overlap);
	return sequenceLength;
	}
	assert(sequence.offset < WILDCOPY_VECLEN);

	/* Copy 8 bytes and spread the offset to be >= 8. */
	ZSTD_overlapCopy8(&op, &match, sequence.offset);

	/* If the match length is > 8 bytes, then continue with the wildcopy. */
	if (sequence.matchLength > 8) {
	assert(op < oMatchEnd);
	ZSTD_wildcopy(op, match, (ptrdiff_t)sequence.matchLength-8, ZSTD_overlap_src_before_dst);
	}
	return sequenceLength;
	}

	static void
	ZSTD_initFseState(ZSTD_fseState* DStatePtr, BIT_DStream_t* bitD, const ZSTD_seqSymbol* dt)
	{
	const void* ptr = dt;
	const ZSTD_seqSymbol_header* const DTableH = (const ZSTD_seqSymbol_header*)ptr;
	DStatePtr->state = BIT_readBits(bitD, DTableH->tableLog);
	DEBUGLOG(6, "ZSTD_initFseState : val=%u using %u bits",
	(U32)DStatePtr->state, DTableH->tableLog);
	BIT_reloadDStream(bitD);
	DStatePtr->table = dt + 1;
	}

	FORCE_INLINE_TEMPLATE void
	ZSTD_updateFseState(ZSTD_fseState* DStatePtr, BIT_DStream_t* bitD)
	{
	ZSTD_seqSymbol const DInfo = DStatePtr->table[DStatePtr->state];
	U32 const nbBits = DInfo.nbBits;
	size_t const lowBits = BIT_readBits(bitD, nbBits);
	DStatePtr->state = DInfo.nextState + lowBits;
	}

	FORCE_INLINE_TEMPLATE void
	ZSTD_updateFseStateWithDInfo(ZSTD_fseState* DStatePtr, BIT_DStream_t* bitD, ZSTD_seqSymbol const DInfo)
	{
	U32 const nbBits = DInfo.nbBits;
	size_t const lowBits = BIT_readBits(bitD, nbBits);
	DStatePtr->state = DInfo.nextState + lowBits;
	}

	/* We need to add at most (ZSTD_WINDOWLOG_MAX_32 - 1) bits to read the maximum
	* offset bits. But we can only read at most (STREAM_ACCUMULATOR_MIN_32 - 1)
	* bits before reloading. This value is the maximum number of bytes we read
	* after reloading when we are decoding long offsets.
	*/
	#define LONG_OFFSETS_MAX_EXTRA_BITS_32 \
	(ZSTD_WINDOWLOG_MAX_32 > STREAM_ACCUMULATOR_MIN_32 \
	? ZSTD_WINDOWLOG_MAX_32 - STREAM_ACCUMULATOR_MIN_32 \
	: 0)

	typedef enum { ZSTD_lo_isRegularOffset, ZSTD_lo_isLongOffset=1 } ZSTD_longOffset_e;
	typedef enum { ZSTD_p_noPrefetch=0, ZSTD_p_prefetch=1 } ZSTD_prefetch_e;

	FORCE_INLINE_TEMPLATE seq_t
	ZSTD_decodeSequence(seqState_t* seqState, const ZSTD_longOffset_e longOffsets, const ZSTD_prefetch_e prefetch)
	{
	seq_t seq;
	ZSTD_seqSymbol const llDInfo = seqState->stateLL.table[seqState->stateLL.state];
	ZSTD_seqSymbol const mlDInfo = seqState->stateML.table[seqState->stateML.state];
	ZSTD_seqSymbol const ofDInfo = seqState->stateOffb.table[seqState->stateOffb.state];
	U32 const llBase = llDInfo.baseValue;
	U32 const mlBase = mlDInfo.baseValue;
	U32 const ofBase = ofDInfo.baseValue;
	BYTE const llBits = llDInfo.nbAdditionalBits;
	BYTE const mlBits = mlDInfo.nbAdditionalBits;
	BYTE const ofBits = ofDInfo.nbAdditionalBits;
	BYTE const totalBits = llBits+mlBits+ofBits;

	/* sequence */
	{ size_t offset;
	if (ofBits > 1) {
	ZSTD_STATIC_ASSERT(ZSTD_lo_isLongOffset == 1);
	ZSTD_STATIC_ASSERT(LONG_OFFSETS_MAX_EXTRA_BITS_32 == 5);
	assert(ofBits <= MaxOff);
	if (MEM_32bits() && longOffsets && (ofBits >= STREAM_ACCUMULATOR_MIN_32)) {
	U32 const extraBits = ofBits - MIN(ofBits, 32 - seqState->DStream.bitsConsumed);
	offset = ofBase + (BIT_readBitsFast(&seqState->DStream, ofBits - extraBits) << extraBits);
	BIT_reloadDStream(&seqState->DStream);
	if (extraBits) offset += BIT_readBitsFast(&seqState->DStream, extraBits);
	assert(extraBits <= LONG_OFFSETS_MAX_EXTRA_BITS_32); /* to avoid another reload */
	} else {
	offset = ofBase + BIT_readBitsFast(&seqState->DStream, ofBits/>0/); /* <= (ZSTD_WINDOWLOG_MAX-1) bits */
	if (MEM_32bits()) BIT_reloadDStream(&seqState->DStream);
	}
	seqState->prevOffset[2] = seqState->prevOffset[1];
	seqState->prevOffset[1] = seqState->prevOffset[0];
	seqState->prevOffset[0] = offset;
	} else {
	U32 const ll0 = (llBase == 0);
	if (LIKELY((ofBits == 0))) {
	if (LIKELY(!ll0))
	offset = seqState->prevOffset[0];
	else {
	offset = seqState->prevOffset[1];
	seqState->prevOffset[1] = seqState->prevOffset[0];
	seqState->prevOffset[0] = offset;
	}
	} else {
	offset = ofBase + ll0 + BIT_readBitsFast(&seqState->DStream, 1);
	{ size_t temp = (offset==3) ? seqState->prevOffset[0] - 1 : seqState->prevOffset[offset];
	temp += !temp; /* 0 is not valid; input is corrupted; force offset to 1 */
	if (offset != 1) seqState->prevOffset[2] = seqState->prevOffset[1];
	seqState->prevOffset[1] = seqState->prevOffset[0];
	seqState->prevOffset[0] = offset = temp;
	} } }
	seq.offset = offset;
	}

	seq.matchLength = mlBase;
	if (mlBits > 0)
	seq.matchLength += BIT_readBitsFast(&seqState->DStream, mlBits/>0/);

	if (MEM_32bits() && (mlBits+llBits >= STREAM_ACCUMULATOR_MIN_32-LONG_OFFSETS_MAX_EXTRA_BITS_32))
	BIT_reloadDStream(&seqState->DStream);
	if (MEM_64bits() && UNLIKELY(totalBits >= STREAM_ACCUMULATOR_MIN_64-(LLFSELog+MLFSELog+OffFSELog)))
	BIT_reloadDStream(&seqState->DStream);
	/* Ensure there are enough bits to read the rest of data in 64-bit mode. */
	ZSTD_STATIC_ASSERT(16+LLFSELog+MLFSELog+OffFSELog < STREAM_ACCUMULATOR_MIN_64);

	seq.litLength = llBase;
	if (llBits > 0)
	seq.litLength += BIT_readBitsFast(&seqState->DStream, llBits/>0/);

	if (MEM_32bits())
	BIT_reloadDStream(&seqState->DStream);

	DEBUGLOG(6, "seq: litL=%u, matchL=%u, offset=%u",
	(U32)seq.litLength, (U32)seq.matchLength, (U32)seq.offset);

	if (prefetch == ZSTD_p_prefetch) {
	size_t const pos = seqState->pos + seq.litLength;
	const BYTE* const matchBase = (seq.offset > pos) ? seqState->dictEnd : seqState->prefixStart;
	seq.match = matchBase + pos - seq.offset; /* note : this operation can overflow when seq.offset is really too large, which can only happen when input is corrupted.
	* No consequence though : no memory access will occur, offset is only used for prefetching */
	seqState->pos = pos + seq.matchLength;
	}

	/* ANS state update
	* gcc-9.0.0 does 2.5% worse with ZSTD_updateFseStateWithDInfo().
	* clang-9.2.0 does 7% worse with ZSTD_updateFseState().
	* Naturally it seems like ZSTD_updateFseStateWithDInfo() should be the
	* better option, so it is the default for other compilers. But, if you
	* measure that it is worse, please put up a pull request.
	*/
	{
	#if defined(__GNUC__) && !defined(__clang__)
	const int kUseUpdateFseState = 1;
	#else
	const int kUseUpdateFseState = 0;
	#endif
	if (kUseUpdateFseState) {
	ZSTD_updateFseState(&seqState->stateLL, &seqState->DStream); /* <= 9 bits */
	ZSTD_updateFseState(&seqState->stateML, &seqState->DStream); /* <= 9 bits */
	if (MEM_32bits()) BIT_reloadDStream(&seqState->DStream); /* <= 18 bits */
	ZSTD_updateFseState(&seqState->stateOffb, &seqState->DStream); /* <= 8 bits */
	} else {
	ZSTD_updateFseStateWithDInfo(&seqState->stateLL, &seqState->DStream, llDInfo); /* <= 9 bits */
	ZSTD_updateFseStateWithDInfo(&seqState->stateML, &seqState->DStream, mlDInfo); /* <= 9 bits */
	if (MEM_32bits()) BIT_reloadDStream(&seqState->DStream); /* <= 18 bits */
	ZSTD_updateFseStateWithDInfo(&seqState->stateOffb, &seqState->DStream, ofDInfo); /* <= 8 bits */
	}
	}

	return seq;
	}

	#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
	static int ZSTD_dictionaryIsActive(ZSTD_DCtx const* dctx, BYTE const* prefixStart, BYTE const* oLitEnd)
	{
	size_t const windowSize = dctx->fParams.windowSize;
	/* No dictionary used. */
	if (dctx->dictContentEndForFuzzing == NULL) return 0;
	/* Dictionary is our prefix. */
	if (prefixStart == dctx->dictContentBeginForFuzzing) return 1;
	/* Dictionary is not our ext-dict. */
	if (dctx->dictEnd != dctx->dictContentEndForFuzzing) return 0;
	/* Dictionary is not within our window size. */
	if ((size_t)(oLitEnd - prefixStart) >= windowSize) return 0;
	/* Dictionary is active. */
	return 1;
	}

	MEM_STATIC void ZSTD_assertValidSequence(
	ZSTD_DCtx const* dctx,
	BYTE const* op, BYTE const* oend,
	seq_t const seq,
	BYTE const* prefixStart, BYTE const* virtualStart)
	{
	size_t const windowSize = dctx->fParams.windowSize;
	size_t const sequenceSize = seq.litLength + seq.matchLength;
	BYTE const* const oLitEnd = op + seq.litLength;
	DEBUGLOG(6, "Checking sequence: litL=%u matchL=%u offset=%u",
	(U32)seq.litLength, (U32)seq.matchLength, (U32)seq.offset);
	assert(op <= oend);
	assert((size_t)(oend - op) >= sequenceSize);
	assert(sequenceSize <= ZSTD_BLOCKSIZE_MAX);
	if (ZSTD_dictionaryIsActive(dctx, prefixStart, oLitEnd)) {
	size_t const dictSize = (size_t)((char const)dctx->dictContentEndForFuzzing - (char const)dctx->dictContentBeginForFuzzing);
	/* Offset must be within the dictionary. */
	assert(seq.offset <= (size_t)(oLitEnd - virtualStart));
	assert(seq.offset <= windowSize + dictSize);
	} else {
	/* Offset must be within our window. */
	assert(seq.offset <= windowSize);
	}
	}
	#endif

	#ifndef ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG
	FORCE_INLINE_TEMPLATE size_t
	DONT_VECTORIZE
	ZSTD_decompressSequences_body( ZSTD_DCtx* dctx,
	void* dst, size_t maxDstSize,
	const void* seqStart, size_t seqSize, int nbSeq,
	const ZSTD_longOffset_e isLongOffset,
	const int frame)
	{
	const BYTE* ip = (const BYTE*)seqStart;
	const BYTE* const iend = ip + seqSize;
	BYTE* const ostart = (BYTE* const)dst;
	BYTE* const oend = ostart + maxDstSize;
	BYTE* op = ostart;
	const BYTE* litPtr = dctx->litPtr;
	const BYTE* const litEnd = litPtr + dctx->litSize;
	const BYTE* const prefixStart = (const BYTE*) (dctx->prefixStart);
	const BYTE* const vBase = (const BYTE*) (dctx->virtualStart);
	const BYTE* const dictEnd = (const BYTE*) (dctx->dictEnd);
	DEBUGLOG(5, "ZSTD_decompressSequences_body");
	(void)frame;

	/* Regen sequences */
	if (nbSeq) {
	seqState_t seqState;
	size_t error = 0;
	dctx->fseEntropy = 1;
	{ U32 i; for (i=0; i<ZSTD_REP_NUM; i++) seqState.prevOffset[i] = dctx->entropy.rep[i]; }
	RETURN_ERROR_IF(
	ERR_isError(BIT_initDStream(&seqState.DStream, ip, iend-ip)),
	corruption_detected, "");
	ZSTD_initFseState(&seqState.stateLL, &seqState.DStream, dctx->LLTptr);
	ZSTD_initFseState(&seqState.stateOffb, &seqState.DStream, dctx->OFTptr);
	ZSTD_initFseState(&seqState.stateML, &seqState.DStream, dctx->MLTptr);
	assert(dst != NULL);

	ZSTD_STATIC_ASSERT(
	BIT_DStream_unfinished < BIT_DStream_completed &&
	BIT_DStream_endOfBuffer < BIT_DStream_completed &&
	BIT_DStream_completed < BIT_DStream_overflow);

	#if defined(__GNUC__) && defined(__x86_64__)
	/* Align the decompression loop to 32 + 16 bytes.
	*
	* zstd compiled with gcc-9 on an Intel i9-9900k shows 10% decompression
	* speed swings based on the alignment of the decompression loop. This
	* performance swing is caused by parts of the decompression loop falling
	* out of the DSB. The entire decompression loop should fit in the DSB,
	* when it can't we get much worse performance. You can measure if you've
	* hit the good case or the bad case with this perf command for some
	* compressed file test.zst:
	*
	* perf stat -e cycles -e instructions -e idq.all_dsb_cycles_any_uops \
	* -e idq.all_mite_cycles_any_uops -- ./zstd -tq test.zst
	*
	* If you see most cycles served out of the MITE you've hit the bad case.
	* If you see most cycles served out of the DSB you've hit the good case.
	* If it is pretty even then you may be in an okay case.
	*
	* I've been able to reproduce this issue on the following CPUs:
	* - Kabylake: Macbook Pro (15-inch, 2019) 2.4 GHz Intel Core i9
	* Use Instruments->Counters to get DSB/MITE cycles.
	* I never got performance swings, but I was able to
	* go from the good case of mostly DSB to half of the
	* cycles served from MITE.
	* - Coffeelake: Intel i9-9900k
	*
	* I haven't been able to reproduce the instability or DSB misses on any
	* of the following CPUS:
	* - Haswell
	* - Broadwell: Intel(R) Xeon(R) CPU E5-2680 v4 @ 2.40GH
	* - Skylake
	*
	* If you are seeing performance stability this script can help test.
	* It tests on 4 commits in zstd where I saw performance change.
	*
	* https://gist.github.com/terrelln/9889fc06a423fd5ca6e99351564473f4
	*/
	__asm__(".p2align 5");
	__asm__("nop");
	__asm__(".p2align 4");
	#endif
	for ( ; ; ) {
	seq_t const sequence = ZSTD_decodeSequence(&seqState, isLongOffset, ZSTD_p_noPrefetch);
	size_t const oneSeqSize = ZSTD_execSequence(op, oend, sequence, &litPtr, litEnd, prefixStart, vBase, dictEnd);
	#if defined(FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION) && defined(FUZZING_ASSERT_VALID_SEQUENCE)
	assert(!ZSTD_isError(oneSeqSize));
	if (frame) ZSTD_assertValidSequence(dctx, op, oend, sequence, prefixStart, vBase);
	#endif
	DEBUGLOG(6, "regenerated sequence size : %u", (U32)oneSeqSize);
	BIT_reloadDStream(&(seqState.DStream));
	/* gcc and clang both don't like early returns in this loop.
	* gcc doesn't like early breaks either.
	* Instead save an error and report it at the end.
	* When there is an error, don't increment op, so we don't
	* overwrite.
	*/
	if (UNLIKELY(ZSTD_isError(oneSeqSize))) error = oneSeqSize;
	else op += oneSeqSize;
	if (UNLIKELY(!--nbSeq)) break;
	}

	/* check if reached exact end */
	DEBUGLOG(5, "ZSTD_decompressSequences_body: after decode loop, remaining nbSeq : %i", nbSeq);
	if (ZSTD_isError(error)) return error;
	RETURN_ERROR_IF(nbSeq, corruption_detected, "");
	RETURN_ERROR_IF(BIT_reloadDStream(&seqState.DStream) < BIT_DStream_completed, corruption_detected, "");
	/* save reps for next block */
	{ U32 i; for (i=0; i<ZSTD_REP_NUM; i++) dctx->entropy.rep[i] = (U32)(seqState.prevOffset[i]); }
	}

	/* last literal segment */
	{ size_t const lastLLSize = litEnd - litPtr;
	RETURN_ERROR_IF(lastLLSize > (size_t)(oend-op), dstSize_tooSmall, "");
	if (op != NULL) {
	memcpy(op, litPtr, lastLLSize);
	op += lastLLSize;
	}
	}

	return op-ostart;
	}

	static size_t
	ZSTD_decompressSequences_default(ZSTD_DCtx* dctx,
	void* dst, size_t maxDstSize,
	const void* seqStart, size_t seqSize, int nbSeq,
	const ZSTD_longOffset_e isLongOffset,
	const int frame)
	{
	return ZSTD_decompressSequences_body(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset, frame);
	}
	#endif /* ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG */

	#ifndef ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT
	FORCE_INLINE_TEMPLATE size_t
	ZSTD_decompressSequencesLong_body(
	ZSTD_DCtx* dctx,
	void* dst, size_t maxDstSize,
	const void* seqStart, size_t seqSize, int nbSeq,
	const ZSTD_longOffset_e isLongOffset,
	const int frame)
	{
	const BYTE* ip = (const BYTE*)seqStart;
	const BYTE* const iend = ip + seqSize;
	BYTE* const ostart = (BYTE* const)dst;
	BYTE* const oend = ostart + maxDstSize;
	BYTE* op = ostart;
	const BYTE* litPtr = dctx->litPtr;
	const BYTE* const litEnd = litPtr + dctx->litSize;
	const BYTE* const prefixStart = (const BYTE*) (dctx->prefixStart);
	const BYTE* const dictStart = (const BYTE*) (dctx->virtualStart);
	const BYTE* const dictEnd = (const BYTE*) (dctx->dictEnd);
	(void)frame;

	/* Regen sequences */
	if (nbSeq) {
	#define STORED_SEQS 4
	#define STORED_SEQS_MASK (STORED_SEQS-1)
	#define ADVANCED_SEQS 4
	seq_t sequences[STORED_SEQS];
	int const seqAdvance = MIN(nbSeq, ADVANCED_SEQS);
	seqState_t seqState;
	int seqNb;
	dctx->fseEntropy = 1;
	{ int i; for (i=0; i<ZSTD_REP_NUM; i++) seqState.prevOffset[i] = dctx->entropy.rep[i]; }
	seqState.prefixStart = prefixStart;
	seqState.pos = (size_t)(op-prefixStart);
	seqState.dictEnd = dictEnd;
	assert(dst != NULL);
	assert(iend >= ip);
	RETURN_ERROR_IF(
	ERR_isError(BIT_initDStream(&seqState.DStream, ip, iend-ip)),
	corruption_detected, "");
	ZSTD_initFseState(&seqState.stateLL, &seqState.DStream, dctx->LLTptr);
	ZSTD_initFseState(&seqState.stateOffb, &seqState.DStream, dctx->OFTptr);
	ZSTD_initFseState(&seqState.stateML, &seqState.DStream, dctx->MLTptr);

	/* prepare in advance */
	for (seqNb=0; (BIT_reloadDStream(&seqState.DStream) <= BIT_DStream_completed) && (seqNb<seqAdvance); seqNb++) {
	sequences[seqNb] = ZSTD_decodeSequence(&seqState, isLongOffset, ZSTD_p_prefetch);
	PREFETCH_L1(sequences[seqNb].match); PREFETCH_L1(sequences[seqNb].match + sequences[seqNb].matchLength - 1); /* note : it's safe to invoke PREFETCH() on any memory address, including invalid ones */
	}
	RETURN_ERROR_IF(seqNb<seqAdvance, corruption_detected, "");

	/* decode and decompress */
	for ( ; (BIT_reloadDStream(&(seqState.DStream)) <= BIT_DStream_completed) && (seqNb<nbSeq) ; seqNb++) {
	seq_t const sequence = ZSTD_decodeSequence(&seqState, isLongOffset, ZSTD_p_prefetch);
	size_t const oneSeqSize = ZSTD_execSequence(op, oend, sequences[(seqNb-ADVANCED_SEQS) & STORED_SEQS_MASK], &litPtr, litEnd, prefixStart, dictStart, dictEnd);
	#if defined(FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION) && defined(FUZZING_ASSERT_VALID_SEQUENCE)
	assert(!ZSTD_isError(oneSeqSize));
	if (frame) ZSTD_assertValidSequence(dctx, op, oend, sequences[(seqNb-ADVANCED_SEQS) & STORED_SEQS_MASK], prefixStart, dictStart);
	#endif
	if (ZSTD_isError(oneSeqSize)) return oneSeqSize;
	PREFETCH_L1(sequence.match); PREFETCH_L1(sequence.match + sequence.matchLength - 1); /* note : it's safe to invoke PREFETCH() on any memory address, including invalid ones */
	sequences[seqNb & STORED_SEQS_MASK] = sequence;
	op += oneSeqSize;
	}
	RETURN_ERROR_IF(seqNb<nbSeq, corruption_detected, "");

	/* finish queue */
	seqNb -= seqAdvance;
	for ( ; seqNb<nbSeq ; seqNb++) {
	size_t const oneSeqSize = ZSTD_execSequence(op, oend, sequences[seqNb&STORED_SEQS_MASK], &litPtr, litEnd, prefixStart, dictStart, dictEnd);
	#if defined(FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION) && defined(FUZZING_ASSERT_VALID_SEQUENCE)
	assert(!ZSTD_isError(oneSeqSize));
	if (frame) ZSTD_assertValidSequence(dctx, op, oend, sequences[seqNb&STORED_SEQS_MASK], prefixStart, dictStart);
	#endif
	if (ZSTD_isError(oneSeqSize)) return oneSeqSize;
	op += oneSeqSize;
	}

	/* save reps for next block */
	{ U32 i; for (i=0; i<ZSTD_REP_NUM; i++) dctx->entropy.rep[i] = (U32)(seqState.prevOffset[i]); }
	}

	/* last literal segment */
	{ size_t const lastLLSize = litEnd - litPtr;
	RETURN_ERROR_IF(lastLLSize > (size_t)(oend-op), dstSize_tooSmall, "");
	if (op != NULL) {
	memcpy(op, litPtr, lastLLSize);
	op += lastLLSize;
	}
	}

	return op-ostart;
	}

	static size_t
	ZSTD_decompressSequencesLong_default(ZSTD_DCtx* dctx,
	void* dst, size_t maxDstSize,
	const void* seqStart, size_t seqSize, int nbSeq,
	const ZSTD_longOffset_e isLongOffset,
	const int frame)
	{
	return ZSTD_decompressSequencesLong_body(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset, frame);
	}
	#endif /* ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT */



	#if DYNAMIC_BMI2

	#ifndef ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG
	static TARGET_ATTRIBUTE("bmi2") size_t
	DONT_VECTORIZE
	ZSTD_decompressSequences_bmi2(ZSTD_DCtx* dctx,
	void* dst, size_t maxDstSize,
	const void* seqStart, size_t seqSize, int nbSeq,
	const ZSTD_longOffset_e isLongOffset,
	const int frame)
	{
	return ZSTD_decompressSequences_body(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset, frame);
	}
	#endif /* ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG */

	#ifndef ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT
	static TARGET_ATTRIBUTE("bmi2") size_t
	ZSTD_decompressSequencesLong_bmi2(ZSTD_DCtx* dctx,
	void* dst, size_t maxDstSize,
	const void* seqStart, size_t seqSize, int nbSeq,
	const ZSTD_longOffset_e isLongOffset,
	const int frame)
	{
	return ZSTD_decompressSequencesLong_body(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset, frame);
	}
	#endif /* ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT */

	#endif /* DYNAMIC_BMI2 */

	typedef size_t (*ZSTD_decompressSequences_t)(
	ZSTD_DCtx* dctx,
	void* dst, size_t maxDstSize,
	const void* seqStart, size_t seqSize, int nbSeq,
	const ZSTD_longOffset_e isLongOffset,
	const int frame);

	#ifndef ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG
	static size_t
	ZSTD_decompressSequences(ZSTD_DCtx* dctx, void* dst, size_t maxDstSize,
	const void* seqStart, size_t seqSize, int nbSeq,
	const ZSTD_longOffset_e isLongOffset,
	const int frame)
	{
	DEBUGLOG(5, "ZSTD_decompressSequences");
	#if DYNAMIC_BMI2
	if (dctx->bmi2) {
	return ZSTD_decompressSequences_bmi2(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset, frame);
	}
	#endif
	return ZSTD_decompressSequences_default(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset, frame);
	}
	#endif /* ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG */


	#ifndef ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT
	/* ZSTD_decompressSequencesLong() :
	* decompression function triggered when a minimum share of offsets is considered "long",
	* aka out of cache.
	* note : "long" definition seems overloaded here, sometimes meaning "wider than bitstream register", and sometimes meaning "farther than memory cache distance".
	* This function will try to mitigate main memory latency through the use of prefetching */
	static size_t
	ZSTD_decompressSequencesLong(ZSTD_DCtx* dctx,
	void* dst, size_t maxDstSize,
	const void* seqStart, size_t seqSize, int nbSeq,
	const ZSTD_longOffset_e isLongOffset,
	const int frame)
	{
	DEBUGLOG(5, "ZSTD_decompressSequencesLong");
	#if DYNAMIC_BMI2
	if (dctx->bmi2) {
	return ZSTD_decompressSequencesLong_bmi2(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset, frame);
	}
	#endif
	return ZSTD_decompressSequencesLong_default(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset, frame);
	}
	#endif /* ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT */



	#if !defined(ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT) && \
	!defined(ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG)
	/* ZSTD_getLongOffsetsShare() :
	* condition : offTable must be valid
	* @return : "share" of long offsets (arbitrarily defined as > (1<<23))
	* compared to maximum possible of (1<<OffFSELog) */
	static unsigned
	ZSTD_getLongOffsetsShare(const ZSTD_seqSymbol* offTable)
	{
	const void* ptr = offTable;
	U32 const tableLog = ((const ZSTD_seqSymbol_header*)ptr)[0].tableLog;
	const ZSTD_seqSymbol* table = offTable + 1;
	U32 const max = 1 << tableLog;
	U32 u, total = 0;
	DEBUGLOG(5, "ZSTD_getLongOffsetsShare: (tableLog=%u)", tableLog);

	assert(max <= (1 << OffFSELog)); /* max not too large */
	for (u=0; u<max; u++) {
	if (table[u].nbAdditionalBits > 22) total += 1;
	}

	assert(tableLog <= OffFSELog);
	total <<= (OffFSELog - tableLog); /* scale to OffFSELog */

	return total;
	}
	#endif

	size_t
	ZSTD_decompressBlock_internal(ZSTD_DCtx* dctx,
	void* dst, size_t dstCapacity,
	const void* src, size_t srcSize, const int frame)
	{ /* blockType == blockCompressed */
	const BYTE* ip = (const BYTE*)src;
	/* isLongOffset must be true if there are long offsets.
	* Offsets are long if they are larger than 2^STREAM_ACCUMULATOR_MIN.
	* We don't expect that to be the case in 64-bit mode.
	* In block mode, window size is not known, so we have to be conservative.
	* (note: but it could be evaluated from current-lowLimit)
	*/
	ZSTD_longOffset_e const isLongOffset = (ZSTD_longOffset_e)(MEM_32bits() && (!frame \|\| (dctx->fParams.windowSize > (1ULL << STREAM_ACCUMULATOR_MIN))));
	DEBUGLOG(5, "ZSTD_decompressBlock_internal (size : %u)", (U32)srcSize);

	RETURN_ERROR_IF(srcSize >= ZSTD_BLOCKSIZE_MAX, srcSize_wrong, "");

	/* Decode literals section */
	{ size_t const litCSize = ZSTD_decodeLiteralsBlock(dctx, src, srcSize);
	DEBUGLOG(5, "ZSTD_decodeLiteralsBlock : %u", (U32)litCSize);
	if (ZSTD_isError(litCSize)) return litCSize;
	ip += litCSize;
	srcSize -= litCSize;
	}

	/* Build Decoding Tables */
	{
	/* These macros control at build-time which decompressor implementation
	* we use. If neither is defined, we do some inspection and dispatch at
	* runtime.
	*/
	#if !defined(ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT) && \
	!defined(ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG)
	int usePrefetchDecoder = dctx->ddictIsCold;
	#endif
	int nbSeq;
	size_t const seqHSize = ZSTD_decodeSeqHeaders(dctx, &nbSeq, ip, srcSize);
	if (ZSTD_isError(seqHSize)) return seqHSize;
	ip += seqHSize;
	srcSize -= seqHSize;

	RETURN_ERROR_IF(dst == NULL && nbSeq > 0, dstSize_tooSmall, "NULL not handled");

	#if !defined(ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT) && \
	!defined(ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG)
	if ( !usePrefetchDecoder
	&& (!frame \|\| (dctx->fParams.windowSize > (1<<24)))
	&& (nbSeq>ADVANCED_SEQS) ) { /* could probably use a larger nbSeq limit */
	U32 const shareLongOffsets = ZSTD_getLongOffsetsShare(dctx->OFTptr);
	U32 const minShare = MEM_64bits() ? 7 : 20; /* heuristic values, correspond to 2.73% and 7.81% */
	usePrefetchDecoder = (shareLongOffsets >= minShare);
	}
	#endif

	dctx->ddictIsCold = 0;

	#if !defined(ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT) && \
	!defined(ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG)
	if (usePrefetchDecoder)
	#endif
	#ifndef ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT
	return ZSTD_decompressSequencesLong(dctx, dst, dstCapacity, ip, srcSize, nbSeq, isLongOffset, frame);
	#endif

	#ifndef ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG
	/* else */
	return ZSTD_decompressSequences(dctx, dst, dstCapacity, ip, srcSize, nbSeq, isLongOffset, frame);
	#endif
	}
	}


	void ZSTD_checkContinuity(ZSTD_DCtx* dctx, const void* dst)
	{
	if (dst != dctx->previousDstEnd) { /* not contiguous */
	dctx->dictEnd = dctx->previousDstEnd;
	dctx->virtualStart = (const char)dst - ((const char)(dctx->previousDstEnd) - (const char*)(dctx->prefixStart));
	dctx->prefixStart = dst;
	dctx->previousDstEnd = dst;
	}
	}


	size_t ZSTD_decompressBlock(ZSTD_DCtx* dctx,
	void* dst, size_t dstCapacity,
	const void* src, size_t srcSize)
	{
	size_t dSize;
	ZSTD_checkContinuity(dctx, dst);
	dSize = ZSTD_decompressBlock_internal(dctx, dst, dstCapacity, src, srcSize, /* frame */ 0);
	dctx->previousDstEnd = (char*)dst + dSize;
	return dSize;
	}
	/** ended inlining decompress/zstd_decompress_block.c **/
	diff --git a/sys/contrib/openzfs/rpm/generic/zfs-dkms.spec.in b/sys/contrib/openzfs/rpm/generic/zfs-dkms.spec.in
	index e0c410c680c2..aab1d9399077 100644
	--- a/sys/contrib/openzfs/rpm/generic/zfs-dkms.spec.in
	+++ b/sys/contrib/openzfs/rpm/generic/zfs-dkms.spec.in
	@@ -1,109 +1,113 @@
	%{?!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(post): dkms >= 2.2.0.3
	+Requires(preun): dkms >= 2.2.0.3
	Requires: gcc, make, perl, diffutils
	+Requires(post): gcc, make, perl, diffutils
	%if 0%{?rhel}%{?fedora}%{?mageia}%{?suse_version}
	Requires: kernel-devel >= @ZFS_META_KVER_MIN@, kernel-devel <= @ZFS_META_KVER_MAX@.999
	+Requires(post): kernel-devel >= @ZFS_META_KVER_MIN@, kernel-devel <= @ZFS_META_KVER_MAX@.999
	Obsoletes: spl-dkms
	%endif
	Provides: %{module}-kmod = %{version}
	AutoReqProv: no

	%if 0%{?rhel}%{?fedora}%{?suse_version}
	# We don't directly use it, but if this isn't installed, rpmbuild as root can
	# crash+corrupt rpmdb
	# See issue #12071
	BuildRequires: ncompress
	%endif

	%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 7fa28ac723eb..4a37ae8ce1d5 100644
	--- a/sys/contrib/openzfs/rpm/generic/zfs.spec.in
	+++ b/sys/contrib/openzfs/rpm/generic/zfs.spec.in
	@@ -1,562 +1,567 @@
	%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: libzpool5 = %{version}
	Requires: libnvpair3 = %{version}
	Requires: libuutil3 = %{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 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
	# We don't directly use it, but if this isn't installed, rpmbuild as root can
	# crash+corrupt rpmdb
	# See issue #12071
	BuildRequires: ncompress
	%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 libzpool5
	Summary: Native ZFS pool library for Linux
	Group: System Environment/Kernel
	Obsoletes: libzpool2
	Obsoletes: libzpool4

	%description -n libzpool5
	This package contains the zpool library, which provides support
	for managing zpools

	%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

	# 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 libzfs5
	This package provides support for managing ZFS filesystems

	%if %{defined ldconfig_scriptlets}
	%ldconfig_scriptlets -n libzfs5
	%else
	%post -n libzfs5 -p /sbin/ldconfig
	%postun -n libzfs5 -p /sbin/ldconfig
	%endif

	%package -n libzfs5-devel
	Summary: Development headers
	Group: System Environment/Kernel
	Requires: libzfs5 = %{version}
	Requires: libzpool5 = %{version}
	Requires: libnvpair3 = %{version}
	Requires: libuutil3 = %{version}
	Provides: libzpool5-devel
	Provides: libnvpair3-devel
	Provides: libuutil3-devel
	Obsoletes: zfs-devel
	Obsoletes: libzfs2-devel
	Obsoletes: 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: libzfs5 = %{version}
	Requires: libnvpair3 = %{version}
	Requires: libffi
	Requires: python%{__python_pkg_version}
	Requires: %{__python_cffi_pkg}
	%if 0%{?rhel}%{?fedora}%{?suse_version}
	+%if 0%{?rhel} >= 8 \|\| 0%{?centos} >= 8 \|\| 0%{?fedora} >= 28
	+BuildRequires: python3-packaging
	+%else
	+BuildRequires: python-packaging
	+%endif
	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}/man4/*
	%{_mandir}/man5/*
	%{_mandir}/man7/*
	%{_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 libzpool5
	%{_libdir}/libzpool.so.*

	%files -n libnvpair3
	%{_libdir}/libnvpair.so.*

	%files -n libuutil3
	%{_libdir}/libuutil.so.*

	%files -n libzfs5
	%{_libdir}/libzfs.so.

	%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/scripts/mancheck.sh b/sys/contrib/openzfs/scripts/mancheck.sh
	index 6ae1fc5becff..0793cc48fa97 100755
	--- a/sys/contrib/openzfs/scripts/mancheck.sh
	+++ b/sys/contrib/openzfs/scripts/mancheck.sh
	@@ -1,43 +1,53 @@
	#!/bin/sh
	#
	# 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.
	#
	-# shellcheck disable=SC2086
	+# shellcheck disable=SC2086,SC2250
	+
	+trap 'rm -f "$stdout_file" "$stderr_file" "$result_file"' EXIT

	if [ "$#" -eq 0 ]; then
	echo "Usage: $0 manpage-directory..."
	exit 1
	fi

	if ! command -v mandoc > /dev/null; then
	echo "skipping mancheck because mandoc is not installed"
	exit 0
	fi

	IFS="
	"
	-
	files="$(find "$@" -type f -name '[1-9]')" \|\| exit 1

	add_excl="$(awk '
	/^.\\" lint-ok:/ {
	print "-e"
	$1 = "mandoc:"
	$2 = FILENAME ":[[:digit:]]+:[[:digit:]]+:"
	print
	}' $files)"

	# Redirect to file instead of 2>&1ing because mandoc flushes inconsistently(?) which tears lines
	# https://github.com/openzfs/zfs/pull/12129/checks?check_run_id=2701608671#step:5:3
	-etmp="$(mktemp)"
	-! { mandoc -Tlint $files 2>"$etmp"; cat "$etmp"; rm -f "$etmp"; } \|
	- grep -vE -e 'mandoc: outdated mandoc.db' -e 'STYLE: referenced manual not found' $add_excl >&2
	+stdout_file="$(mktemp)"
	+stderr_file="$(mktemp)"
	+mandoc -Tlint $files 1>"$stdout_file" 2>"$stderr_file"
	+result_file="$(mktemp)"
	+grep -vhE -e 'mandoc: outdated mandoc.db' -e 'STYLE: referenced manual not found' $add_excl "$stdout_file" "$stderr_file" > "$result_file"
	+
	+if [ -s "$result_file" ]; then
	+ cat "$result_file"
	+ exit 1
	+else
	+ echo "no errors found"
	+fi
	diff --git a/sys/contrib/openzfs/scripts/zfs-tests.sh b/sys/contrib/openzfs/scripts/zfs-tests.sh
	index ac28788582f9..60499e09e249 100755
	--- a/sys/contrib/openzfs/scripts/zfs-tests.sh
	+++ b/sys/contrib/openzfs/scripts/zfs-tests.sh
	@@ -1,716 +1,748 @@
	#!/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 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 2020 OmniOS Community Edition (OmniOSce) Association.
	+#
	+
	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=zfs-tests.sh
	VERBOSE="no"
	QUIET=""
	CLEANUP="yes"
	CLEANUPALL="no"
	LOOPBACK="yes"
	STACK_TRACER="no"
	FILESIZE="4G"
	DEFAULT_RUNFILES="common.run,$(uname \| tr '[:upper:]' '[:lower:]').run"
	RUNFILES=${RUNFILES:-$DEFAULT_RUNFILES}
	FILEDIR=${FILEDIR:-/var/tmp}
	DISKS=${DISKS:-""}
	SINGLETEST=""
	SINGLETESTUSER="root"
	TAGS=""
	ITERATIONS=1
	ZFS_DBGMSG="$STF_SUITE/callbacks/zfs_dbgmsg.ksh"
	ZFS_DMESG="$STF_SUITE/callbacks/zfs_dmesg.ksh"
	UNAME=$(uname -s)
	+RERUN=""

	# Override some defaults if on FreeBSD
	if [ "$UNAME" = "FreeBSD" ] ; then
	TESTFAIL_CALLBACKS=${TESTFAIL_CALLBACKS:-"$ZFS_DMESG"}
	LOSETUP=/sbin/mdconfig
	DMSETUP=/sbin/gpart
	else
	ZFS_MMP="$STF_SUITE/callbacks/zfs_mmp.ksh"
	TESTFAIL_CALLBACKS=${TESTFAIL_CALLBACKS:-"$ZFS_DBGMSG:$ZFS_DMESG:$ZFS_MMP"}
	LOSETUP=${LOSETUP:-/sbin/losetup}
	DMSETUP=${DMSETUP:-/sbin/dmsetup}
	fi

	#
	# Log an informational message when additional verbosity is enabled.
	#
	msg() {
	if [ "$VERBOSE" = "yes" ]; then
	echo "$@"
	fi
	}

	#
	# Log a failure message, cleanup, and return an error.
	#
	fail() {
	echo "$PROG: $1" >&2
	cleanup
	exit 1
	}

	cleanup_freebsd_loopback() {
	for TEST_LOOPBACK in ${LOOPBACKS}; do
	if [ -c "/dev/${TEST_LOOPBACK}" ]; then
	sudo "${LOSETUP}" -d -u "${TEST_LOOPBACK}" \|\|
	echo "Failed to destroy: ${TEST_LOOPBACK}"
	fi
	done
	}

	cleanup_linux_loopback() {
	for TEST_LOOPBACK in ${LOOPBACKS}; do
	LOOP_DEV=$(basename "$TEST_LOOPBACK")
	DM_DEV=$(sudo "${DMSETUP}" ls 2>/dev/null \| \
	grep "${LOOP_DEV}" \| cut -f1)

	if [ -n "$DM_DEV" ]; then
	sudo "${DMSETUP}" remove "${DM_DEV}" \|\|
	echo "Failed to remove: ${DM_DEV}"
	fi

	if [ -n "${TEST_LOOPBACK}" ]; then
	sudo "${LOSETUP}" -d "${TEST_LOOPBACK}" \|\|
	echo "Failed to remove: ${TEST_LOOPBACK}"
	fi
	done
	}

	#
	# Attempt to remove loopback devices and files which where created earlier
	# by this script to run the test framework. The '-k' option may be passed
	# to the script to suppress cleanup for debugging purposes.
	#
	cleanup() {
	if [ "$CLEANUP" = "no" ]; then
	return 0
	fi


	if [ "$LOOPBACK" = "yes" ]; then
	if [ "$UNAME" = "FreeBSD" ] ; then
	cleanup_freebsd_loopback
	else
	cleanup_linux_loopback
	fi
	fi

	for TEST_FILE in ${FILES}; do
	rm -f "${TEST_FILE}" >/dev/null 2>&1
	done

	if [ "$STF_PATH_REMOVE" = "yes" ] && [ -d "$STF_PATH" ]; then
	rm -Rf "$STF_PATH"
	fi
	}
	trap cleanup EXIT

	#
	# Attempt to remove all testpools (testpool.XXX), unopened dm devices,
	# loopback devices, and files. This is a useful way to cleanup a previous
	# test run failure which has left the system in an unknown state. This can
	# be dangerous and should only be used in a dedicated test environment.
	#
	cleanup_all() {
	TEST_POOLS=$(sudo "$ZPOOL" list -H -o name \| grep testpool)
	if [ "$UNAME" = "FreeBSD" ] ; then
	TEST_LOOPBACKS=$(sudo "${LOSETUP}" -l)
	else
	TEST_LOOPBACKS=$(sudo "${LOSETUP}" -a\|grep file-vdev\|cut -f1 -d:)
	fi
	TEST_FILES=$(ls /var/tmp/file-vdev* 2>/dev/null)

	msg
	msg "--- Cleanup ---"
	msg "Removing pool(s): $(echo "${TEST_POOLS}" \| tr '\n' ' ')"
	for TEST_POOL in $TEST_POOLS; do
	sudo "$ZPOOL" destroy "${TEST_POOL}"
	done

	if [ "$UNAME" != "FreeBSD" ] ; then
	msg "Removing dm(s): $(sudo "${DMSETUP}" ls \|
	grep loop \| tr '\n' ' ')"
	sudo "${DMSETUP}" remove_all
	fi

	msg "Removing loopback(s): $(echo "${TEST_LOOPBACKS}" \| tr '\n' ' ')"
	for TEST_LOOPBACK in $TEST_LOOPBACKS; do
	if [ "$UNAME" = "FreeBSD" ] ; then
	sudo "${LOSETUP}" -d -u "${TEST_LOOPBACK}"
	else
	sudo "${LOSETUP}" -d "${TEST_LOOPBACK}"
	fi
	done

	msg "Removing files(s): $(echo "${TEST_FILES}" \| tr '\n' ' ')"
	for TEST_FILE in $TEST_FILES; do
	sudo rm -f "${TEST_FILE}"
	done
	}

	#
	# Takes a name as the only arguments and looks for the following variations
	# on that name. If one is found it is returned.
	#
	# $RUNFILE_DIR/<name>
	# $RUNFILE_DIR/<name>.run
	# <name>
	# <name>.run
	#
	find_runfile() {
	NAME=$1
	RESULT=""

	if [ -f "$RUNFILE_DIR/$NAME" ]; then
	RESULT="$RUNFILE_DIR/$NAME"
	elif [ -f "$RUNFILE_DIR/$NAME.run" ]; then
	RESULT="$RUNFILE_DIR/$NAME.run"
	elif [ -f "$NAME" ]; then
	RESULT="$NAME"
	elif [ -f "$NAME.run" ]; then
	RESULT="$NAME.run"
	fi

	echo "$RESULT"
	}

	#
	# Symlink file if it appears under any of the given paths.
	#
	create_links() {
	dir_list="$1"
	file_list="$2"

	[ -n "$STF_PATH" ] \|\| fail "STF_PATH wasn't correctly set"

	for i in $file_list; do
	for j in $dir_list; do
	[ ! -e "$STF_PATH/$i" ] \|\| continue

	if [ ! -d "$j/$i" ] && [ -e "$j/$i" ]; then
	ln -sf "$j/$i" "$STF_PATH/$i" \|\| \
	fail "Couldn't link $i"
	break
	fi
	done

	[ ! -e "$STF_PATH/$i" ] && \
	STF_MISSING_BIN="$STF_MISSING_BIN $i"
	done
	STF_MISSING_BIN=${STF_MISSING_BIN# }
	}

	#
	# Constrain the path to limit the available binaries to a known set.
	# When running in-tree a top level ./bin/ directory is created for
	# convenience, otherwise a temporary directory is used.
	#
	constrain_path() {
	. "$STF_SUITE/include/commands.cfg"

	# On FreeBSD, base system zfs utils are in /sbin and OpenZFS utils
	# install to /usr/local/sbin. To avoid testing the wrong utils we
	# need /usr/local to come before / in the path search order.
	SYSTEM_DIRS="/usr/local/bin /usr/local/sbin"
	SYSTEM_DIRS="$SYSTEM_DIRS /usr/bin /usr/sbin /bin /sbin $LIBEXEC_DIR"

	if [ "$INTREE" = "yes" ]; then
	# Constrained path set to ./zfs/bin/
	STF_PATH="$BIN_DIR"
	STF_PATH_REMOVE="no"
	STF_MISSING_BIN=""
	if [ ! -d "$STF_PATH" ]; then
	mkdir "$STF_PATH"
	chmod 755 "$STF_PATH" \|\| fail "Couldn't chmod $STF_PATH"
	fi

	# Special case links for standard zfs utilities
	DIRS="$(find "$CMD_DIR" -type d \( ! -name .deps -a \
	! -name .libs \) -print \| tr '\n' ' ')"
	create_links "$DIRS" "$ZFS_FILES"

	# Special case links for zfs test suite utilities
	DIRS="$(find "$STF_SUITE" -type d \( ! -name .deps -a \
	! -name .libs \) -print \| tr '\n' ' ')"
	create_links "$DIRS" "$ZFSTEST_FILES"
	else
	# Constrained path set to /var/tmp/constrained_path.*
	SYSTEMDIR=${SYSTEMDIR:-/var/tmp/constrained_path.XXXXXX}
	STF_PATH=$(mktemp -d "$SYSTEMDIR")
	STF_PATH_REMOVE="yes"
	STF_MISSING_BIN=""

	chmod 755 "$STF_PATH" \|\| fail "Couldn't chmod $STF_PATH"

	# Special case links for standard zfs utilities
	create_links "$SYSTEM_DIRS" "$ZFS_FILES"

	# Special case links for zfs test suite utilities
	create_links "$STF_SUITE/bin" "$ZFSTEST_FILES"
	fi

	# Standard system utilities
	SYSTEM_FILES="$SYSTEM_FILES_COMMON"
	if [ "$UNAME" = "FreeBSD" ] ; then
	SYSTEM_FILES="$SYSTEM_FILES $SYSTEM_FILES_FREEBSD"
	else
	SYSTEM_FILES="$SYSTEM_FILES $SYSTEM_FILES_LINUX"
	fi
	create_links "$SYSTEM_DIRS" "$SYSTEM_FILES"

	# Exceptions
	ln -fs "$STF_PATH/awk" "$STF_PATH/nawk"
	if [ "$UNAME" = "Linux" ] ; then
	ln -fs /sbin/fsck.ext4 "$STF_PATH/fsck"
	ln -fs /sbin/mkfs.ext4 "$STF_PATH/newfs"
	ln -fs "$STF_PATH/gzip" "$STF_PATH/compress"
	ln -fs "$STF_PATH/gunzip" "$STF_PATH/uncompress"
	ln -fs "$STF_PATH/exportfs" "$STF_PATH/share"
	ln -fs "$STF_PATH/exportfs" "$STF_PATH/unshare"
	elif [ "$UNAME" = "FreeBSD" ] ; then
	ln -fs /usr/local/bin/ksh93 "$STF_PATH/ksh"
	fi
	}

	#
	# Output a useful usage message.
	#
	usage() {
	cat << EOF
	USAGE:
	$0 [-hvqxkfS] [-s SIZE] [-r RUNFILES] [-t PATH] [-u USER]

	DESCRIPTION:
	ZFS Test Suite launch script

	OPTIONS:
	-h Show this message
	-v Verbose zfs-tests.sh output
	-q Quiet test-runner output
	-x Remove all testpools, dm, lo, and files (unsafe)
	-k Disable cleanup after test failure
	-f Use files only, disables block device tests
	-S Enable stack tracer (negative performance impact)
	-c Only create and populate constrained path
	+ -R Automatically rerun failing tests
	-n NFSFILE Use the nfsfile to determine the NFS configuration
	-I NUM Number of iterations
	-d DIR Use DIR for files and loopback devices
	-s SIZE Use vdevs of SIZE (default: 4G)
	-r RUNFILES Run tests in RUNFILES (default: ${DEFAULT_RUNFILES})
	-t PATH Run single test at PATH relative to test suite
	-T TAGS Comma separated list of tags (default: 'functional')
	-u USER Run single test as USER (default: root)

	EXAMPLES:
	# Run the default (linux) suite of tests and output the configuration used.
	$0 -v

	# Run a smaller suite of tests designed to run more quickly.
	$0 -r linux-fast

	# Run a single test
	$0 -t tests/functional/cli_root/zfs_bookmark/zfs_bookmark_cliargs.ksh

	# Cleanup a previous run of the test suite prior to testing, run the
	# default (linux) suite of tests and perform no cleanup on exit.
	$0 -x

	EOF
	}

	-while getopts 'hvqxkfScn:d:s:r:?t:T:u:I:' OPTION; do
	+while getopts 'hvqxkfScRn:d:s:r:?t:T:u:I:' OPTION; do
	case $OPTION in
	h)
	usage
	exit 1
	;;
	v)
	VERBOSE="yes"
	;;
	q)
	QUIET="yes"
	;;
	x)
	CLEANUPALL="yes"
	;;
	k)
	CLEANUP="no"
	;;
	f)
	LOOPBACK="no"
	;;
	S)
	STACK_TRACER="yes"
	;;
	c)
	constrain_path
	exit
	;;
	+ R)
	+ RERUN="yes"
	+ ;;
	n)
	nfsfile=$OPTARG
	[ -f "$nfsfile" ] \|\| fail "Cannot read file: $nfsfile"
	export NFS=1
	. "$nfsfile"
	;;
	d)
	FILEDIR="$OPTARG"
	;;
	I)
	ITERATIONS="$OPTARG"
	if [ "$ITERATIONS" -le 0 ]; then
	fail "Iterations must be greater than 0."
	fi
	;;
	s)
	FILESIZE="$OPTARG"
	;;
	r)
	RUNFILES="$OPTARG"
	;;
	t)
	if [ -n "$SINGLETEST" ]; then
	fail "-t can only be provided once."
	fi
	SINGLETEST="$OPTARG"
	;;
	T)
	TAGS="$OPTARG"
	;;
	u)
	SINGLETESTUSER="$OPTARG"
	;;
	?)
	usage
	exit
	;;
	esac
	done

	shift $((OPTIND-1))

	FILES=${FILES:-"$FILEDIR/file-vdev0 $FILEDIR/file-vdev1 $FILEDIR/file-vdev2"}
	LOOPBACKS=${LOOPBACKS:-""}

	if [ -n "$SINGLETEST" ]; then
	if [ -n "$TAGS" ]; then
	fail "-t and -T are mutually exclusive."
	fi
	RUNFILE_DIR="/var/tmp"
	RUNFILES="zfs-tests.$$.run"
	SINGLEQUIET="False"

	if [ -n "$QUIET" ]; then
	SINGLEQUIET="True"
	fi

	cat >$RUNFILE_DIR/$RUNFILES << EOF
	[DEFAULT]
	pre =
	quiet = $SINGLEQUIET
	pre_user = root
	user = $SINGLETESTUSER
	timeout = 600
	post_user = root
	post =
	outputdir = /var/tmp/test_results
	EOF
	SINGLETESTDIR=$(dirname "$SINGLETEST")
	SINGLETESTFILE=$(basename "$SINGLETEST")
	SETUPSCRIPT=
	CLEANUPSCRIPT=

	if [ -f "$STF_SUITE/$SINGLETESTDIR/setup.ksh" ]; then
	SETUPSCRIPT="setup"
	fi

	if [ -f "$STF_SUITE/$SINGLETESTDIR/cleanup.ksh" ]; then
	CLEANUPSCRIPT="cleanup"
	fi

	cat >>$RUNFILE_DIR/$RUNFILES << EOF

	[$SINGLETESTDIR]
	tests = ['$SINGLETESTFILE']
	pre = $SETUPSCRIPT
	post = $CLEANUPSCRIPT
	tags = ['functional']
	EOF
	fi

	#
	# Use default tag if none was specified
	#
	TAGS=${TAGS:='functional'}

	#
	# Attempt to locate the runfiles describing the test workload.
	#
	R=""
	IFS=,
	for RUNFILE in $RUNFILES; do
	if [ -n "$RUNFILE" ]; then
	SAVED_RUNFILE="$RUNFILE"
	RUNFILE=$(find_runfile "$RUNFILE")
	[ -z "$RUNFILE" ] && fail "Cannot find runfile: $SAVED_RUNFILE"
	R="$R,$RUNFILE"
	fi

	if [ ! -r "$RUNFILE" ]; then
	fail "Cannot read runfile: $RUNFILE"
	fi
	done
	unset IFS
	RUNFILES=${R#,}

	#
	# This script should not be run as root. Instead the test user, which may
	# be a normal user account, needs to be configured such that it can
	# run commands via sudo passwordlessly.
	#
	if [ "$(id -u)" = "0" ]; then
	fail "This script must not be run as root."
	fi

	if [ "$(sudo whoami)" != "root" ]; then
	fail "Passwordless sudo access required."
	fi

	#
	# Constrain the available binaries to a known set.
	#
	constrain_path

	#
	# Check if ksh exists
	#
	if [ "$UNAME" = "FreeBSD" ]; then
	sudo ln -fs /usr/local/bin/ksh93 /bin/ksh
	fi
	[ -e "$STF_PATH/ksh" ] \|\| fail "This test suite requires ksh."
	[ -e "$STF_SUITE/include/default.cfg" ] \|\| fail \
	"Missing $STF_SUITE/include/default.cfg file."

	#
	# Verify the ZFS module stack is loaded.
	#
	if [ "$STACK_TRACER" = "yes" ]; then
	sudo "${ZFS_SH}" -S >/dev/null 2>&1
	else
	sudo "${ZFS_SH}" >/dev/null 2>&1
	fi

	#
	# Attempt to cleanup all previous state for a new test run.
	#
	if [ "$CLEANUPALL" = "yes" ]; then
	cleanup_all
	fi

	#
	# By default preserve any existing pools
	# NOTE: Since 'zpool list' outputs a newline-delimited list convert $KEEP from
	# space-delimited to newline-delimited.
	#
	if [ -z "${KEEP}" ]; then
	KEEP="$(sudo "$ZPOOL" list -H -o name)"
	if [ -z "${KEEP}" ]; then
	KEEP="rpool"
	fi
	else
	KEEP="$(echo "$KEEP" \| tr '[:blank:]' '\n')"
	fi

	#
	# NOTE: The following environment variables are undocumented
	# and should be used for testing purposes only:
	#
	# __ZFS_POOL_EXCLUDE - don't iterate over the pools it lists
	# __ZFS_POOL_RESTRICT - iterate only over the pools it lists
	#
	# See libzfs/libzfs_config.c for more information.
	#
	if [ "$UNAME" = "FreeBSD" ] ; then
	__ZFS_POOL_EXCLUDE="$(echo "$KEEP" \| tr -s '\n' ' ')"
	else
	__ZFS_POOL_EXCLUDE="$(echo "$KEEP" \| sed ':a;N;s/\n/ /g;ba')"
	fi

	. "$STF_SUITE/include/default.cfg"

	#
	# No DISKS have been provided so a basic file or loopback based devices
	# must be created for the test suite to use.
	#
	if [ -z "${DISKS}" ]; then
	#
	# If this is a performance run, prevent accidental use of
	# loopback devices.
	#
	[ "$TAGS" = "perf" ] && fail "Running perf tests without disks."

	#
	# Create sparse files for the test suite. These may be used
	# directory or have loopback devices layered on them.
	#
	for TEST_FILE in ${FILES}; do
	[ -f "$TEST_FILE" ] && fail "Failed file exists: ${TEST_FILE}"
	truncate -s "${FILESIZE}" "${TEST_FILE}" \|\|
	fail "Failed creating: ${TEST_FILE} ($?)"
	done

	#
	# If requested setup loopback devices backed by the sparse files.
	#
	if [ "$LOOPBACK" = "yes" ]; then
	test -x "$LOSETUP" \|\| fail "$LOSETUP utility must be installed"

	for TEST_FILE in ${FILES}; do
	if [ "$UNAME" = "FreeBSD" ] ; then
	MDDEVICE=$(sudo "${LOSETUP}" -a -t vnode -f "${TEST_FILE}")
	if [ -z "$MDDEVICE" ] ; then
	fail "Failed: ${TEST_FILE} -> loopback"
	fi
	DISKS="$DISKS $MDDEVICE"
	LOOPBACKS="$LOOPBACKS $MDDEVICE"
	else
	TEST_LOOPBACK=$(sudo "${LOSETUP}" -f)
	sudo "${LOSETUP}" "${TEST_LOOPBACK}" "${TEST_FILE}" \|\|
	fail "Failed: ${TEST_FILE} -> ${TEST_LOOPBACK}"
	BASELOOPBACK=$(basename "$TEST_LOOPBACK")
	DISKS="$DISKS $BASELOOPBACK"
	LOOPBACKS="$LOOPBACKS $TEST_LOOPBACK"
	fi
	done
	DISKS=${DISKS# }
	LOOPBACKS=${LOOPBACKS# }
	else
	DISKS="$FILES"
	fi
	fi

	#
	# It may be desirable to test with fewer disks than the default when running
	# the performance tests, but the functional tests require at least three.
	#
	NUM_DISKS=$(echo "${DISKS}" \| awk '{print NF}')
	if [ "$TAGS" != "perf" ]; then
	[ "$NUM_DISKS" -lt 3 ] && fail "Not enough disks ($NUM_DISKS/3 minimum)"
	fi

	#
	# Disable SELinux until the ZFS Test Suite has been updated accordingly.
	#
	if [ -x "$STF_PATH/setenforce" ]; then
	sudo setenforce permissive >/dev/null 2>&1
	fi

	#
	# Enable internal ZFS debug log and clear it.
	#
	if [ -e /sys/module/zfs/parameters/zfs_dbgmsg_enable ]; then
	sudo /bin/sh -c "echo 1 >/sys/module/zfs/parameters/zfs_dbgmsg_enable"
	sudo /bin/sh -c "echo 0 >/proc/spl/kstat/zfs/dbgmsg"
	fi

	msg
	msg "--- Configuration ---"
	msg "Runfiles: $RUNFILES"
	msg "STF_TOOLS: $STF_TOOLS"
	msg "STF_SUITE: $STF_SUITE"
	msg "STF_PATH: $STF_PATH"
	msg "FILEDIR: $FILEDIR"
	msg "FILES: $FILES"
	msg "LOOPBACKS: $LOOPBACKS"
	msg "DISKS: $DISKS"
	msg "NUM_DISKS: $NUM_DISKS"
	msg "FILESIZE: $FILESIZE"
	msg "ITERATIONS: $ITERATIONS"
	msg "TAGS: $TAGS"
	msg "STACK_TRACER: $STACK_TRACER"
	msg "Keep pool(s): $KEEP"
	msg "Missing util(s): $STF_MISSING_BIN"
	msg ""

	export STF_TOOLS
	export STF_SUITE
	export STF_PATH
	export DISKS
	export FILEDIR
	export KEEP
	export __ZFS_POOL_EXCLUDE
	export TESTFAIL_CALLBACKS
	export PATH=$STF_PATH

	if [ "$UNAME" = "FreeBSD" ] ; then
	mkdir -p "$FILEDIR" \|\| true
	RESULTS_FILE=$(mktemp -u "${FILEDIR}/zts-results.XXXXXX")
	REPORT_FILE=$(mktemp -u "${FILEDIR}/zts-report.XXXXXX")
	else
	RESULTS_FILE=$(mktemp -u -t zts-results.XXXXXX -p "$FILEDIR")
	REPORT_FILE=$(mktemp -u -t zts-report.XXXXXX -p "$FILEDIR")
	fi

	#
	# Run all the tests as specified.
	#
	msg "${TEST_RUNNER} ${QUIET:+-q}" \
	"-c \"${RUNFILES}\"" \
	"-T \"${TAGS}\"" \
	"-i \"${STF_SUITE}\"" \
	"-I \"${ITERATIONS}\""
	${TEST_RUNNER} ${QUIET:+-q} \
	-c "${RUNFILES}" \
	-T "${TAGS}" \
	-i "${STF_SUITE}" \
	-I "${ITERATIONS}" \
	2>&1 \| tee "$RESULTS_FILE"
	-
	#
	# Analyze the results.
	#
	-${ZTS_REPORT} "$RESULTS_FILE" >"$REPORT_FILE"
	+${ZTS_REPORT} ${RERUN:+--no-maybes} "$RESULTS_FILE" >"$REPORT_FILE"
	RESULT=$?
	+
	+if [ "$RESULT" -eq "2" ] && [ -n "$RERUN" ]; then
	+ MAYBES="$($ZTS_REPORT --list-maybes)"
	+ TEMP_RESULTS_FILE=$(mktemp -u -t zts-results-tmp.XXXXX -p "$FILEDIR")
	+ TEST_LIST=$(mktemp -u -t test-list.XXXXX -p "$FILEDIR")
	+ grep "^Test:.*\[FAIL\]" "$RESULTS_FILE" >"$TEMP_RESULTS_FILE"
	+ for test_name in $MAYBES; do
	+ grep "$test_name " "$TEMP_RESULTS_FILE" >>"$TEST_LIST"
	+ done
	+ ${TEST_RUNNER} ${QUIET:+-q} \
	+ -c "${RUNFILES}" \
	+ -T "${TAGS}" \
	+ -i "${STF_SUITE}" \
	+ -I "${ITERATIONS}" \
	+ -l "${TEST_LIST}" \
	+ 2>&1 \| tee "$RESULTS_FILE"
	+ #
	+ # Analyze the results.
	+ #
	+ ${ZTS_REPORT} --no-maybes "$RESULTS_FILE" >"$REPORT_FILE"
	+ RESULT=$?
	+fi
	+
	+
	cat "$REPORT_FILE"

	RESULTS_DIR=$(awk '/^Log directory/ { print $3 }' "$RESULTS_FILE")
	if [ -d "$RESULTS_DIR" ]; then
	cat "$RESULTS_FILE" "$REPORT_FILE" >"$RESULTS_DIR/results"
	fi

	rm -f "$RESULTS_FILE" "$REPORT_FILE"

	if [ -n "$SINGLETEST" ]; then
	rm -f "$RUNFILES" >/dev/null 2>&1
	fi

	exit ${RESULT}
	diff --git a/sys/contrib/openzfs/tests/runfiles/common.run b/sys/contrib/openzfs/tests/runfiles/common.run
	index a62cd6ad39f5..97ee7b8ae241 100644
	--- a/sys/contrib/openzfs/tests/runfiles/common.run
	+++ b/sys/contrib/openzfs/tests/runfiles/common.run
	@@ -1,946 +1,946 @@
	#
	# 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_clone_livelist_dedup',
	'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_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',
	'zpool_create_features_009_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/crtime]
	tests = ['crtime_001_pos' ]
	tags = ['functional', 'crtime']

	[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']
	+tests = ['mmap_write_001_pos', 'mmap_read_001_pos', 'mmap_seek_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_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']
	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']
	tags = ['functional', 'l2arc']

	[tests/functional/zpool_influxdb]
	tests = ['zpool_influxdb']
	tags = ['functional', 'zpool_influxdb']
	diff --git a/sys/contrib/openzfs/tests/runfiles/sanity.run b/sys/contrib/openzfs/tests/runfiles/sanity.run
	index b1d2c73de959..3f4eb302f1e0 100644
	--- a/sys/contrib/openzfs/tests/runfiles/sanity.run
	+++ b/sys/contrib/openzfs/tests/runfiles/sanity.run
	@@ -1,622 +1,621 @@
	#
	# 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 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']
	+tests = ['history_004_pos', 'history_005_neg', 'history_007_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']
	+ '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/test-runner.py.in b/sys/contrib/openzfs/tests/test-runner/bin/test-runner.py.in
	index bbabf247c1dc..d32e05c45392 100755
	--- a/sys/contrib/openzfs/tests/test-runner/bin/test-runner.py.in
	+++ b/sys/contrib/openzfs/tests/test-runner/bin/test-runner.py.in
	@@ -1,1056 +1,1107 @@
	#!/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) 2012, 2018 by Delphix. All rights reserved.
	# Copyright (c) 2019 Datto Inc.
	#
	# This script must remain compatible with Python 2.6+ and Python 3.4+.
	#

	# some python 2.7 system don't have a configparser shim
	try:
	import configparser
	except ImportError:
	import ConfigParser as configparser

	import os
	import sys
	import ctypes
	+import re

	from datetime import datetime
	from optparse import OptionParser
	from pwd import getpwnam
	from pwd import getpwuid
	from select import select
	from subprocess import PIPE
	from subprocess import Popen
	from threading import Timer
	from time import time

	BASEDIR = '/var/tmp/test_results'
	TESTDIR = '/usr/share/zfs/'
	KILL = 'kill'
	TRUE = 'true'
	SUDO = 'sudo'
	LOG_FILE = 'LOG_FILE'
	LOG_OUT = 'LOG_OUT'
	LOG_ERR = 'LOG_ERR'
	LOG_FILE_OBJ = None

	# some python 2.7 system don't have a concept of monotonic time
	CLOCK_MONOTONIC_RAW = 4 # see <linux/time.h>


	class timespec(ctypes.Structure):
	_fields_ = [
	('tv_sec', ctypes.c_long),
	('tv_nsec', ctypes.c_long)
	]


	librt = ctypes.CDLL('librt.so.1', use_errno=True)
	clock_gettime = librt.clock_gettime
	clock_gettime.argtypes = [ctypes.c_int, ctypes.POINTER(timespec)]


	def monotonic_time():
	t = timespec()
	if clock_gettime(CLOCK_MONOTONIC_RAW, ctypes.pointer(t)) != 0:
	errno_ = ctypes.get_errno()
	raise OSError(errno_, os.strerror(errno_))
	return t.tv_sec + t.tv_nsec * 1e-9


	class Result(object):
	total = 0
	runresults = {'PASS': 0, 'FAIL': 0, 'SKIP': 0, 'KILLED': 0, 'RERAN': 0}

	def __init__(self):
	self.starttime = None
	self.returncode = None
	self.runtime = ''
	self.stdout = []
	self.stderr = []
	self.result = ''

	def done(self, proc, killed, reran):
	"""
	Finalize the results of this Cmd.
	"""
	Result.total += 1
	m, s = divmod(monotonic_time() - self.starttime, 60)
	self.runtime = '%02d:%02d' % (m, s)
	self.returncode = proc.returncode
	if reran is True:
	Result.runresults['RERAN'] += 1
	if killed:
	self.result = 'KILLED'
	Result.runresults['KILLED'] += 1
	elif self.returncode == 0:
	self.result = 'PASS'
	Result.runresults['PASS'] += 1
	elif self.returncode == 4:
	self.result = 'SKIP'
	Result.runresults['SKIP'] += 1
	elif self.returncode != 0:
	self.result = 'FAIL'
	Result.runresults['FAIL'] += 1


	class Output(object):
	"""
	This class is a slightly modified version of the 'Stream' class found
	here: http://goo.gl/aSGfv
	"""
	def __init__(self, stream):
	self.stream = stream
	self._buf = b''
	self.lines = []

	def fileno(self):
	return self.stream.fileno()

	def read(self, drain=0):
	"""
	Read from the file descriptor. If 'drain' set, read until EOF.
	"""
	while self._read() is not None:
	if not drain:
	break

	def _read(self):
	"""
	Read up to 4k of data from this output stream. Collect the output
	up to the last newline, and append it to any leftover data from a
	previous call. The lines are stored as a (timestamp, data) tuple
	for easy sorting/merging later.
	"""
	fd = self.fileno()
	buf = os.read(fd, 4096)
	if not buf:
	return None
	if b'\n' not in buf:
	self._buf += buf
	return []

	buf = self._buf + buf
	tmp, rest = buf.rsplit(b'\n', 1)
	self._buf = rest
	now = datetime.now()
	rows = tmp.split(b'\n')
	self.lines += [(now, r) for r in rows]


	class Cmd(object):
	verified_users = []

	def __init__(self, pathname, identifier=None, outputdir=None,
	timeout=None, user=None, tags=None):
	self.pathname = pathname
	self.identifier = identifier
	self.outputdir = outputdir or 'BASEDIR'
	"""
	The timeout for tests is measured in wall-clock time
	"""
	self.timeout = timeout
	self.user = user or ''
	self.killed = False
	self.reran = None
	self.result = Result()

	if self.timeout is None:
	self.timeout = 60

	def __str__(self):
	return '''\
	Pathname: %s
	Identifier: %s
	Outputdir: %s
	Timeout: %d
	User: %s
	''' % (self.pathname, self.identifier, self.outputdir, self.timeout, self.user)

	def kill_cmd(self, proc, keyboard_interrupt=False):
	"""
	Kill a running command due to timeout, or ^C from the keyboard. If
	sudo is required, this user was verified previously.
	"""
	self.killed = True
	do_sudo = len(self.user) != 0
	signal = '-TERM'

	cmd = [SUDO, KILL, signal, str(proc.pid)]
	if not do_sudo:
	del cmd[0]

	try:
	kp = Popen(cmd)
	kp.wait()
	except Exception:
	pass

	"""
	If this is not a user-initiated kill and the test has not been
	reran before we consider if the test needs to be reran:
	If the test has spent some time hibernating and didn't run the whole
	length of time before being timed out we will rerun the test.
	"""
	if keyboard_interrupt is False and self.reran is None:
	runtime = monotonic_time() - self.result.starttime
	if int(self.timeout) > runtime:
	self.killed = False
	self.reran = False
	self.run(False)
	self.reran = True

	def update_cmd_privs(self, cmd, user):
	"""
	If a user has been specified to run this Cmd and we're not already
	running as that user, prepend the appropriate sudo command to run
	as that user.
	"""
	me = getpwuid(os.getuid())

	if not user or user is me:
	if os.path.isfile(cmd+'.ksh') and os.access(cmd+'.ksh', os.X_OK):
	cmd += '.ksh'
	if os.path.isfile(cmd+'.sh') and os.access(cmd+'.sh', os.X_OK):
	cmd += '.sh'
	return cmd

	if not os.path.isfile(cmd):
	if os.path.isfile(cmd+'.ksh') and os.access(cmd+'.ksh', os.X_OK):
	cmd += '.ksh'
	if os.path.isfile(cmd+'.sh') and os.access(cmd+'.sh', os.X_OK):
	cmd += '.sh'

	ret = '%s -E -u %s %s' % (SUDO, user, cmd)
	return ret.split(' ')

	def collect_output(self, proc):
	"""
	Read from stdout/stderr as data becomes available, until the
	process is no longer running. Return the lines from the stdout and
	stderr Output objects.
	"""
	out = Output(proc.stdout)
	err = Output(proc.stderr)
	res = []
	while proc.returncode is None:
	proc.poll()
	res = select([out, err], [], [], .1)
	for fd in res[0]:
	fd.read()
	for fd in res[0]:
	fd.read(drain=1)

	return out.lines, err.lines

	def run(self, dryrun):
	"""
	This is the main function that runs each individual test.
	Determine whether or not the command requires sudo, and modify it
	if needed. Run the command, and update the result object.
	"""
	if dryrun is True:
	print(self)
	return

	privcmd = self.update_cmd_privs(self.pathname, self.user)
	try:
	old = os.umask(0)
	if not os.path.isdir(self.outputdir):
	os.makedirs(self.outputdir, mode=0o777)
	os.umask(old)
	except OSError as e:
	fail('%s' % e)

	self.result.starttime = monotonic_time()
	proc = Popen(privcmd, stdout=PIPE, stderr=PIPE)
	# Allow a special timeout value of 0 to mean infinity
	if int(self.timeout) == 0:
	self.timeout = sys.maxsize
	t = Timer(int(self.timeout), self.kill_cmd, [proc])

	try:
	t.start()
	self.result.stdout, self.result.stderr = self.collect_output(proc)
	except KeyboardInterrupt:
	self.kill_cmd(proc, True)
	fail('\nRun terminated at user request.')
	finally:
	t.cancel()

	if self.reran is not False:
	self.result.done(proc, self.killed, self.reran)

	def skip(self):
	"""
	Initialize enough of the test result that we can log a skipped
	command.
	"""
	Result.total += 1
	Result.runresults['SKIP'] += 1
	self.result.stdout = self.result.stderr = []
	self.result.starttime = monotonic_time()
	m, s = divmod(monotonic_time() - self.result.starttime, 60)
	self.result.runtime = '%02d:%02d' % (m, s)
	self.result.result = 'SKIP'

	def log(self, options, suppress_console=False):
	"""
	This function is responsible for writing all output. This includes
	the console output, the logfile of all results (with timestamped
	merged stdout and stderr), and for each test, the unmodified
	stdout/stderr/merged in its own file.
	"""

	logname = getpwuid(os.getuid()).pw_name
	rer = ''
	if self.reran is True:
	rer = ' (RERAN)'
	user = ' (run as %s)' % (self.user if len(self.user) else logname)
	if self.identifier:
	msga = 'Test (%s): %s%s ' % (self.identifier, self.pathname, user)
	else:
	msga = 'Test: %s%s ' % (self.pathname, user)
	msgb = '[%s] [%s]%s\n' % (self.result.runtime, self.result.result, rer)
	pad = ' ' * (80 - (len(msga) + len(msgb)))
	result_line = msga + pad + msgb

	# The result line is always written to the log file. If -q was
	# specified only failures are written to the console, otherwise
	# the result line is written to the console. The console output
	# may be suppressed by calling log() with suppress_console=True.
	write_log(bytearray(result_line, encoding='utf-8'), LOG_FILE)
	if not suppress_console:
	if not options.quiet:
	write_log(result_line, LOG_OUT)
	elif options.quiet and self.result.result != 'PASS':
	write_log(result_line, LOG_OUT)

	lines = sorted(self.result.stdout + self.result.stderr,
	key=lambda x: x[0])

	# Write timestamped output (stdout and stderr) to the logfile
	for dt, line in lines:
	timestamp = bytearray(dt.strftime("%H:%M:%S.%f ")[:11],
	encoding='utf-8')
	write_log(b'%s %s\n' % (timestamp, line), LOG_FILE)

	# Write the separate stdout/stderr/merged files, if the data exists
	if len(self.result.stdout):
	with open(os.path.join(self.outputdir, 'stdout'), 'wb') as out:
	for _, line in self.result.stdout:
	os.write(out.fileno(), b'%s\n' % line)
	if len(self.result.stderr):
	with open(os.path.join(self.outputdir, 'stderr'), 'wb') as err:
	for _, line in self.result.stderr:
	os.write(err.fileno(), b'%s\n' % line)
	if len(self.result.stdout) and len(self.result.stderr):
	with open(os.path.join(self.outputdir, 'merged'), 'wb') as merged:
	for _, line in lines:
	os.write(merged.fileno(), b'%s\n' % line)


	class Test(Cmd):
	props = ['outputdir', 'timeout', 'user', 'pre', 'pre_user', 'post',
	'post_user', 'failsafe', 'failsafe_user', 'tags']

	def __init__(self, pathname,
	pre=None, pre_user=None, post=None, post_user=None,
	failsafe=None, failsafe_user=None, tags=None, **kwargs):
	super(Test, self).__init__(pathname, **kwargs)
	self.pre = pre or ''
	self.pre_user = pre_user or ''
	self.post = post or ''
	self.post_user = post_user or ''
	self.failsafe = failsafe or ''
	self.failsafe_user = failsafe_user or ''
	self.tags = tags or []

	def __str__(self):
	post_user = pre_user = failsafe_user = ''
	if len(self.pre_user):
	pre_user = ' (as %s)' % (self.pre_user)
	if len(self.post_user):
	post_user = ' (as %s)' % (self.post_user)
	if len(self.failsafe_user):
	failsafe_user = ' (as %s)' % (self.failsafe_user)
	return '''\
	Pathname: %s
	Identifier: %s
	Outputdir: %s
	Timeout: %d
	User: %s
	Pre: %s%s
	Post: %s%s
	Failsafe: %s%s
	Tags: %s
	''' % (self.pathname, self.identifier, self.outputdir, self.timeout, self.user,
	self.pre, pre_user, self.post, post_user, self.failsafe,
	failsafe_user, self.tags)

	def verify(self):
	"""
	Check the pre/post/failsafe scripts, user and Test. Omit the Test from
	this run if there are any problems.
	"""
	files = [self.pre, self.pathname, self.post, self.failsafe]
	users = [self.pre_user, self.user, self.post_user, self.failsafe_user]

	for f in [f for f in files if len(f)]:
	if not verify_file(f):
	write_log("Warning: Test '%s' not added to this run because"
	" it failed verification.\n" % f, LOG_ERR)
	return False

	for user in [user for user in users if len(user)]:
	if not verify_user(user):
	write_log("Not adding Test '%s' to this run.\n" %
	self.pathname, LOG_ERR)
	return False

	return True

	def run(self, options):
	"""
	Create Cmd instances for the pre/post/failsafe scripts. If the pre
	script doesn't pass, skip this Test. Run the post script regardless.
	If the Test is killed, also run the failsafe script.
	"""
	odir = os.path.join(self.outputdir, os.path.basename(self.pre))
	pretest = Cmd(self.pre, identifier=self.identifier, outputdir=odir,
	timeout=self.timeout, user=self.pre_user)
	test = Cmd(self.pathname, identifier=self.identifier,
	outputdir=self.outputdir, timeout=self.timeout,
	user=self.user)
	odir = os.path.join(self.outputdir, os.path.basename(self.failsafe))
	failsafe = Cmd(self.failsafe, identifier=self.identifier,
	outputdir=odir, timeout=self.timeout,
	user=self.failsafe_user)
	odir = os.path.join(self.outputdir, os.path.basename(self.post))
	posttest = Cmd(self.post, identifier=self.identifier, outputdir=odir,
	timeout=self.timeout, user=self.post_user)

	cont = True
	if len(pretest.pathname):
	pretest.run(options.dryrun)
	cont = pretest.result.result == 'PASS'
	pretest.log(options)

	if cont:
	test.run(options.dryrun)
	if test.result.result == 'KILLED' and len(failsafe.pathname):
	failsafe.run(options.dryrun)
	failsafe.log(options, suppress_console=True)
	else:
	test.skip()

	test.log(options)

	if len(posttest.pathname):
	posttest.run(options.dryrun)
	posttest.log(options)


	class TestGroup(Test):
	props = Test.props + ['tests']

	def __init__(self, pathname, tests=None, **kwargs):
	super(TestGroup, self).__init__(pathname, **kwargs)
	self.tests = tests or []

	def __str__(self):
	post_user = pre_user = failsafe_user = ''
	if len(self.pre_user):
	pre_user = ' (as %s)' % (self.pre_user)
	if len(self.post_user):
	post_user = ' (as %s)' % (self.post_user)
	if len(self.failsafe_user):
	failsafe_user = ' (as %s)' % (self.failsafe_user)
	return '''\
	Pathname: %s
	Identifier: %s
	Outputdir: %s
	Tests: %s
	Timeout: %s
	User: %s
	Pre: %s%s
	Post: %s%s
	Failsafe: %s%s
	Tags: %s
	''' % (self.pathname, self.identifier, self.outputdir, self.tests,
	self.timeout, self.user, self.pre, pre_user, self.post, post_user,
	self.failsafe, failsafe_user, self.tags)

	+ def filter(self, keeplist):
	+ self.tests = [x for x in self.tests if x in keeplist]
	+
	def verify(self):
	"""
	Check the pre/post/failsafe scripts, user and tests in this TestGroup.
	Omit the TestGroup entirely, or simply delete the relevant tests in the
	group, if that's all that's required.
	"""
	# If the pre/post/failsafe scripts are relative pathnames, convert to
	# absolute, so they stand a chance of passing verification.
	if len(self.pre) and not os.path.isabs(self.pre):
	self.pre = os.path.join(self.pathname, self.pre)
	if len(self.post) and not os.path.isabs(self.post):
	self.post = os.path.join(self.pathname, self.post)
	if len(self.failsafe) and not os.path.isabs(self.failsafe):
	self.post = os.path.join(self.pathname, self.post)

	auxfiles = [self.pre, self.post, self.failsafe]
	users = [self.pre_user, self.user, self.post_user, self.failsafe_user]

	for f in [f for f in auxfiles if len(f)]:
	if f != self.failsafe and self.pathname != os.path.dirname(f):
	write_log("Warning: TestGroup '%s' not added to this run. "
	"Auxiliary script '%s' exists in a different "
	"directory.\n" % (self.pathname, f), LOG_ERR)
	return False

	if not verify_file(f):
	write_log("Warning: TestGroup '%s' not added to this run. "
	"Auxiliary script '%s' failed verification.\n" %
	(self.pathname, f), LOG_ERR)
	return False

	for user in [user for user in users if len(user)]:
	if not verify_user(user):
	write_log("Not adding TestGroup '%s' to this run.\n" %
	self.pathname, LOG_ERR)
	return False

	# If one of the tests is invalid, delete it, log it, and drive on.
	for test in self.tests:
	if not verify_file(os.path.join(self.pathname, test)):
	del self.tests[self.tests.index(test)]
	write_log("Warning: Test '%s' removed from TestGroup '%s' "
	"because it failed verification.\n" %
	(test, self.pathname), LOG_ERR)

	return len(self.tests) != 0

	def run(self, options):
	"""
	Create Cmd instances for the pre/post/failsafe scripts. If the pre
	script doesn't pass, skip all the tests in this TestGroup. Run the
	post script regardless. Run the failsafe script when a test is killed.
	"""
	# tags assigned to this test group also include the test names
	if options.tags and not set(self.tags).intersection(set(options.tags)):
	return

	odir = os.path.join(self.outputdir, os.path.basename(self.pre))
	pretest = Cmd(self.pre, outputdir=odir, timeout=self.timeout,
	user=self.pre_user, identifier=self.identifier)
	odir = os.path.join(self.outputdir, os.path.basename(self.post))
	posttest = Cmd(self.post, outputdir=odir, timeout=self.timeout,
	user=self.post_user, identifier=self.identifier)

	cont = True
	if len(pretest.pathname):
	pretest.run(options.dryrun)
	cont = pretest.result.result == 'PASS'
	pretest.log(options)

	for fname in self.tests:
	odir = os.path.join(self.outputdir, fname)
	test = Cmd(os.path.join(self.pathname, fname), outputdir=odir,
	timeout=self.timeout, user=self.user,
	identifier=self.identifier)
	odir = os.path.join(odir, os.path.basename(self.failsafe))
	failsafe = Cmd(self.failsafe, outputdir=odir, timeout=self.timeout,
	user=self.failsafe_user, identifier=self.identifier)
	if cont:
	test.run(options.dryrun)
	if test.result.result == 'KILLED' and len(failsafe.pathname):
	failsafe.run(options.dryrun)
	failsafe.log(options, suppress_console=True)
	else:
	test.skip()

	test.log(options)

	if len(posttest.pathname):
	posttest.run(options.dryrun)
	posttest.log(options)


	class TestRun(object):
	props = ['quiet', 'outputdir']

	def __init__(self, options):
	self.tests = {}
	self.testgroups = {}
	self.starttime = time()
	self.timestamp = datetime.now().strftime('%Y%m%dT%H%M%S')
	self.outputdir = os.path.join(options.outputdir, self.timestamp)
	self.setup_logging(options)
	self.defaults = [
	('outputdir', BASEDIR),
	('quiet', False),
	('timeout', 60),
	('user', ''),
	('pre', ''),
	('pre_user', ''),
	('post', ''),
	('post_user', ''),
	('failsafe', ''),
	('failsafe_user', ''),
	('tags', [])
	]

	def __str__(self):
	s = 'TestRun:\n outputdir: %s\n' % self.outputdir
	s += 'TESTS:\n'
	for key in sorted(self.tests.keys()):
	s += '%s%s' % (self.tests[key].__str__(), '\n')
	s += 'TESTGROUPS:\n'
	for key in sorted(self.testgroups.keys()):
	s += '%s%s' % (self.testgroups[key].__str__(), '\n')
	return s

	def addtest(self, pathname, options):
	"""
	Create a new Test, and apply any properties that were passed in
	from the command line. If it passes verification, add it to the
	TestRun.
	"""
	test = Test(pathname)
	for prop in Test.props:
	setattr(test, prop, getattr(options, prop))

	if test.verify():
	self.tests[pathname] = test

	def addtestgroup(self, dirname, filenames, options):
	"""
	Create a new TestGroup, and apply any properties that were passed
	in from the command line. If it passes verification, add it to the
	TestRun.
	"""
	if dirname not in self.testgroups:
	testgroup = TestGroup(dirname)
	for prop in Test.props:
	setattr(testgroup, prop, getattr(options, prop))

	# Prevent pre/post/failsafe scripts from running as regular tests
	for f in [testgroup.pre, testgroup.post, testgroup.failsafe]:
	if f in filenames:
	del filenames[filenames.index(f)]

	self.testgroups[dirname] = testgroup
	self.testgroups[dirname].tests = sorted(filenames)

	testgroup.verify()

	+ def filter(self, keeplist):
	+ for group in list(self.testgroups.keys()):
	+ if group not in keeplist:
	+ del self.testgroups[group]
	+ continue
	+
	+ g = self.testgroups[group]
	+
	+ if g.pre and os.path.basename(g.pre) in keeplist[group]:
	+ continue
	+
	+ g.filter(keeplist[group])
	+
	+ for test in list(self.tests.keys()):
	+ directory, base = os.path.split(test)
	+ if directory not in keeplist or base not in keeplist[directory]:
	+ del self.tests[test]
	+
	def read(self, options):
	"""
	Read in the specified runfiles, and apply the TestRun properties
	listed in the 'DEFAULT' section to our TestRun. Then read each
	section, and apply the appropriate properties to the Test or
	TestGroup. Properties from individual sections override those set
	in the 'DEFAULT' section. If the Test or TestGroup passes
	verification, add it to the TestRun.
	"""
	config = configparser.RawConfigParser()
	parsed = config.read(options.runfiles)
	failed = options.runfiles - set(parsed)
	if len(failed):
	files = ' '.join(sorted(failed))
	fail("Couldn't read config files: %s" % files)

	for opt in TestRun.props:
	if config.has_option('DEFAULT', opt):
	setattr(self, opt, config.get('DEFAULT', opt))
	self.outputdir = os.path.join(self.outputdir, self.timestamp)

	testdir = options.testdir

	for section in config.sections():
	if 'tests' in config.options(section):
	parts = section.split(':', 1)
	sectiondir = parts[0]
	identifier = parts[1] if len(parts) == 2 else None
	if os.path.isdir(sectiondir):
	pathname = sectiondir
	elif os.path.isdir(os.path.join(testdir, sectiondir)):
	pathname = os.path.join(testdir, sectiondir)
	else:
	pathname = sectiondir

	testgroup = TestGroup(os.path.abspath(pathname),
	identifier=identifier)
	for prop in TestGroup.props:
	for sect in ['DEFAULT', section]:
	if config.has_option(sect, prop):
	if prop == 'tags':
	setattr(testgroup, prop,
	eval(config.get(sect, prop)))
	elif prop == 'failsafe':
	failsafe = config.get(sect, prop)
	setattr(testgroup, prop,
	os.path.join(testdir, failsafe))
	else:
	setattr(testgroup, prop,
	config.get(sect, prop))

	# Repopulate tests using eval to convert the string to a list
	testgroup.tests = eval(config.get(section, 'tests'))

	if testgroup.verify():
	self.testgroups[section] = testgroup
	else:
	test = Test(section)
	for prop in Test.props:
	for sect in ['DEFAULT', section]:
	if config.has_option(sect, prop):
	if prop == 'failsafe':
	failsafe = config.get(sect, prop)
	setattr(test, prop,
	os.path.join(testdir, failsafe))
	else:
	setattr(test, prop, config.get(sect, prop))

	if test.verify():
	self.tests[section] = test

	def write(self, options):
	"""
	Create a configuration file for editing and later use. The
	'DEFAULT' section of the config file is created from the
	properties that were specified on the command line. Tests are
	simply added as sections that inherit everything from the
	'DEFAULT' section. TestGroups are the same, except they get an
	option including all the tests to run in that directory.
	"""

	defaults = dict([(prop, getattr(options, prop)) for prop, _ in
	self.defaults])
	config = configparser.RawConfigParser(defaults)

	for test in sorted(self.tests.keys()):
	config.add_section(test)
	+ for prop in Test.props:
	+ if prop not in self.props:
	+ config.set(test, prop,
	+ getattr(self.tests[test], prop))

	for testgroup in sorted(self.testgroups.keys()):
	config.add_section(testgroup)
	config.set(testgroup, 'tests', self.testgroups[testgroup].tests)
	+ for prop in TestGroup.props:
	+ if prop not in self.props:
	+ config.set(testgroup, prop,
	+ getattr(self.testgroups[testgroup], prop))

	try:
	with open(options.template, 'w') as f:
	return config.write(f)
	except IOError:
	fail('Could not open \'%s\' for writing.' % options.template)

	def complete_outputdirs(self):
	"""
	Collect all the pathnames for Tests, and TestGroups. Work
	backwards one pathname component at a time, to create a unique
	directory name in which to deposit test output. Tests will be able
	to write output files directly in the newly modified outputdir.
	TestGroups will be able to create one subdirectory per test in the
	outputdir, and are guaranteed uniqueness because a group can only
	contain files in one directory. Pre and post tests will create a
	directory rooted at the outputdir of the Test or TestGroup in
	question for their output. Failsafe scripts will create a directory
	rooted at the outputdir of each Test for their output.
	"""
	done = False
	components = 0
	tmp_dict = dict(list(self.tests.items()) +
	list(self.testgroups.items()))
	total = len(tmp_dict)
	base = self.outputdir

	while not done:
	paths = []
	components -= 1
	for testfile in list(tmp_dict.keys()):
	uniq = '/'.join(testfile.split('/')[components:]).lstrip('/')
	if uniq not in paths:
	paths.append(uniq)
	tmp_dict[testfile].outputdir = os.path.join(base, uniq)
	else:
	break
	done = total == len(paths)

	def setup_logging(self, options):
	"""
	This function creates the output directory and gets a file object
	for the logfile. This function must be called before write_log()
	can be used.
	"""
	if options.dryrun is True:
	return

	global LOG_FILE_OBJ
	- if options.cmd != 'wrconfig':
	+ if not options.template:
	try:
	old = os.umask(0)
	os.makedirs(self.outputdir, mode=0o777)
	os.umask(old)
	filename = os.path.join(self.outputdir, 'log')
	LOG_FILE_OBJ = open(filename, buffering=0, mode='wb')
	except OSError as e:
	fail('%s' % e)

	def run(self, options):
	"""
	Walk through all the Tests and TestGroups, calling run().
	"""
	try:
	os.chdir(self.outputdir)
	except OSError:
	fail('Could not change to directory %s' % self.outputdir)
	# make a symlink to the output for the currently running test
	logsymlink = os.path.join(self.outputdir, '../current')
	if os.path.islink(logsymlink):
	os.unlink(logsymlink)
	if not os.path.exists(logsymlink):
	os.symlink(self.outputdir, logsymlink)
	else:
	write_log('Could not make a symlink to directory %s\n' %
	self.outputdir, LOG_ERR)
	iteration = 0
	while iteration < options.iterations:
	for test in sorted(self.tests.keys()):
	self.tests[test].run(options)
	for testgroup in sorted(self.testgroups.keys()):
	self.testgroups[testgroup].run(options)
	iteration += 1

	def summary(self):
	if Result.total == 0:
	return 2

	print('\nResults Summary')
	for key in list(Result.runresults.keys()):
	if Result.runresults[key] != 0:
	print('%s\t% 4d' % (key, Result.runresults[key]))

	m, s = divmod(time() - self.starttime, 60)
	h, m = divmod(m, 60)
	print('\nRunning Time:\t%02d:%02d:%02d' % (h, m, s))
	print('Percent passed:\t%.1f%%' % ((float(Result.runresults['PASS']) /
	float(Result.total)) * 100))
	print('Log directory:\t%s' % self.outputdir)

	if Result.runresults['FAIL'] > 0:
	return 1

	if Result.runresults['KILLED'] > 0:
	return 1

	if Result.runresults['RERAN'] > 0:
	return 3

	return 0


	def write_log(msg, target):
	"""
	Write the provided message to standard out, standard error or
	the logfile. If specifying LOG_FILE, then `msg` must be a bytes
	like object. This way we can still handle output from tests that
	may be in unexpected encodings.
	"""
	if target == LOG_OUT:
	os.write(sys.stdout.fileno(), bytearray(msg, encoding='utf-8'))
	elif target == LOG_ERR:
	os.write(sys.stderr.fileno(), bytearray(msg, encoding='utf-8'))
	elif target == LOG_FILE:
	os.write(LOG_FILE_OBJ.fileno(), msg)
	else:
	fail('log_msg called with unknown target "%s"' % target)


	def verify_file(pathname):
	"""
	Verify that the supplied pathname is an executable regular file.
	"""
	if os.path.isdir(pathname) or os.path.islink(pathname):
	return False

	for ext in '', '.ksh', '.sh':
	script_path = pathname + ext
	if os.path.isfile(script_path) and os.access(script_path, os.X_OK):
	return True

	return False


	def verify_user(user):
	"""
	Verify that the specified user exists on this system, and can execute
	sudo without being prompted for a password.
	"""
	testcmd = [SUDO, '-n', '-u', user, TRUE]

	if user in Cmd.verified_users:
	return True

	try:
	getpwnam(user)
	except KeyError:
	write_log("Warning: user '%s' does not exist.\n" % user,
	LOG_ERR)
	return False

	p = Popen(testcmd)
	p.wait()
	if p.returncode != 0:
	write_log("Warning: user '%s' cannot use passwordless sudo.\n" % user,
	LOG_ERR)
	return False
	else:
	Cmd.verified_users.append(user)

	return True


	def find_tests(testrun, options):
	"""
	For the given list of pathnames, add files as Tests. For directories,
	if do_groups is True, add the directory as a TestGroup. If False,
	recursively search for executable files.
	"""

	for p in sorted(options.pathnames):
	if os.path.isdir(p):
	for dirname, _, filenames in os.walk(p):
	if options.do_groups:
	testrun.addtestgroup(dirname, filenames, options)
	else:
	for f in sorted(filenames):
	testrun.addtest(os.path.join(dirname, f), options)
	else:
	testrun.addtest(p, options)


	+def filter_tests(testrun, options):
	+ try:
	+ fh = open(options.logfile, "r")
	+ except Exception as e:
	+ fail('%s' % e)
	+
	+ failed = {}
	+ while True:
	+ line = fh.readline()
	+ if not line:
	+ break
	+ m = re.match(r'Test: .(tests/.)/(\S+).*\[FAIL\]', line)
	+ if not m:
	+ continue
	+ group, test = m.group(1, 2)
	+ try:
	+ failed[group].append(test)
	+ except KeyError:
	+ failed[group] = [test]
	+ fh.close()
	+
	+ testrun.filter(failed)
	+
	+
	def fail(retstr, ret=1):
	print('%s: %s' % (sys.argv[0], retstr))
	exit(ret)


	def options_cb(option, opt_str, value, parser):
	- path_options = ['outputdir', 'template', 'testdir']
	-
	- if option.dest == 'runfiles' and '-w' in parser.rargs or \
	- option.dest == 'template' and '-c' in parser.rargs:
	- fail('-c and -w are mutually exclusive.')
	+ path_options = ['outputdir', 'template', 'testdir', 'logfile']

	if opt_str in parser.rargs:
	fail('%s may only be specified once.' % opt_str)

	if option.dest == 'runfiles':
	parser.values.cmd = 'rdconfig'
	value = set(os.path.abspath(p) for p in value.split(','))
	- if option.dest == 'template':
	- parser.values.cmd = 'wrconfig'
	if option.dest == 'tags':
	value = [x.strip() for x in value.split(',')]

	if option.dest in path_options:
	setattr(parser.values, option.dest, os.path.abspath(value))
	else:
	setattr(parser.values, option.dest, value)


	def parse_args():
	parser = OptionParser()
	parser.add_option('-c', action='callback', callback=options_cb,
	type='string', dest='runfiles', metavar='runfiles',
	help='Specify tests to run via config files.')
	parser.add_option('-d', action='store_true', default=False, dest='dryrun',
	help='Dry run. Print tests, but take no other action.')
	+ parser.add_option('-l', action='callback', callback=options_cb,
	+ default=None, dest='logfile', metavar='logfile',
	+ type='string',
	+ help='Read logfile and re-run tests which failed.')
	parser.add_option('-g', action='store_true', default=False,
	dest='do_groups', help='Make directories TestGroups.')
	parser.add_option('-o', action='callback', callback=options_cb,
	default=BASEDIR, dest='outputdir', type='string',
	metavar='outputdir', help='Specify an output directory.')
	parser.add_option('-i', action='callback', callback=options_cb,
	default=TESTDIR, dest='testdir', type='string',
	metavar='testdir', help='Specify a test directory.')
	parser.add_option('-p', action='callback', callback=options_cb,
	default='', dest='pre', metavar='script',
	type='string', help='Specify a pre script.')
	parser.add_option('-P', action='callback', callback=options_cb,
	default='', dest='post', metavar='script',
	type='string', help='Specify a post script.')
	parser.add_option('-q', action='store_true', default=False, dest='quiet',
	help='Silence on the console during a test run.')
	parser.add_option('-s', action='callback', callback=options_cb,
	default='', dest='failsafe', metavar='script',
	type='string', help='Specify a failsafe script.')
	parser.add_option('-S', action='callback', callback=options_cb,
	default='', dest='failsafe_user',
	metavar='failsafe_user', type='string',
	help='Specify a user to execute the failsafe script.')
	parser.add_option('-t', action='callback', callback=options_cb, default=60,
	dest='timeout', metavar='seconds', type='int',
	help='Timeout (in seconds) for an individual test.')
	parser.add_option('-u', action='callback', callback=options_cb,
	default='', dest='user', metavar='user', type='string',
	help='Specify a different user name to run as.')
	parser.add_option('-w', action='callback', callback=options_cb,
	default=None, dest='template', metavar='template',
	type='string', help='Create a new config file.')
	parser.add_option('-x', action='callback', callback=options_cb, default='',
	dest='pre_user', metavar='pre_user', type='string',
	help='Specify a user to execute the pre script.')
	parser.add_option('-X', action='callback', callback=options_cb, default='',
	dest='post_user', metavar='post_user', type='string',
	help='Specify a user to execute the post script.')
	parser.add_option('-T', action='callback', callback=options_cb, default='',
	dest='tags', metavar='tags', type='string',
	help='Specify tags to execute specific test groups.')
	parser.add_option('-I', action='callback', callback=options_cb, default=1,
	dest='iterations', metavar='iterations', type='int',
	help='Number of times to run the test run.')
	(options, pathnames) = parser.parse_args()

	- if not options.runfiles and not options.template:
	- options.cmd = 'runtests'
	-
	if options.runfiles and len(pathnames):
	fail('Extraneous arguments.')

	options.pathnames = [os.path.abspath(path) for path in pathnames]

	return options


	def main():
	options = parse_args()
	+
	testrun = TestRun(options)

	- if options.cmd == 'runtests':
	- find_tests(testrun, options)
	- elif options.cmd == 'rdconfig':
	+ if options.runfiles:
	testrun.read(options)
	- elif options.cmd == 'wrconfig':
	+ else:
	find_tests(testrun, options)
	+
	+ if options.logfile:
	+ filter_tests(testrun, options)
	+
	+ if options.template:
	testrun.write(options)
	exit(0)
	- else:
	- fail('Unknown command specified')

	testrun.complete_outputdirs()
	testrun.run(options)
	exit(testrun.summary())


	if __name__ == '__main__':
	main()
	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 cc1ee6db0913..c3a679675280 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,447 +1,479 @@
	#!/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
	+import argparse

	#
	# 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 the statx(2) system call on Linux which was first
	# introduced in the 4.11 kernel.
	#
	statx_reason = 'Kernel statx(2) system call required on Linux'

	#
	# 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_root/zpool_import/import_rewind_device_replaced':
	+ ['FAIL', rewind_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],
	'crtime/crtime_001_pos': ['SKIP', statx_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],
	'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_receive/receive-o-x_props_override':
	['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],
	'delegate/zfs_allow_003_pos': ['FAIL', known_reason],
	'inheritance/inherit_001_pos': ['FAIL', '11829'],
	'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_012_pos': ['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_online_002_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


	+class ListMaybesAction(argparse.Action):
	+ def __init__(self,
	+ option_strings,
	+ dest="SUPPRESS",
	+ default="SUPPRESS",
	+ help="list flaky tests and exit"):
	+ super(ListMaybesAction, self).__init__(
	+ option_strings=option_strings,
	+ dest=dest,
	+ default=default,
	+ nargs=0,
	+ help=help)
	+
	+ def __call__(self, parser, namespace, values, option_string=None):
	+ for test in maybe:
	+ print(test)
	+ sys.exit(0)
	+
	+
	if __name__ == "__main__":
	- if len(sys.argv) != 2:
	- usage('usage: %s <pathname>' % sys.argv[0])
	- results = process_results(sys.argv[1])
	+ parser = argparse.ArgumentParser(description='Analyze ZTS logs')
	+ parser.add_argument('logfile')
	+ parser.add_argument('--list-maybes', action=ListMaybesAction)
	+ parser.add_argument('--no-maybes', action='store_false', dest='maybes')
	+ args = parser.parse_args()
	+
	+ results = process_results(args.logfile)

	if summary['total'] == 0:
	print("\n\nNo test results were found.")
	print("Log directory: %s" % summary['logfile'])
	sys.exit(0)

	expected = []
	unexpected = []
	+ all_maybes = True

	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:
	+ if (test in known and results[test] in known[test][0]):
	expected.append(test)
	+ elif test in maybe and results[test] in maybe[test][0]:
	+ if results[test] == 'SKIP' or args.maybes:
	+ expected.append(test)
	+ elif not args.maybes:
	+ unexpected.append(test)
	+ else:
	+ unexpected.append(test)
	+ all_maybes = False

	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)
	+ elif not args.maybes and all_maybes:
	+ sys.exit(2)
	else:
	sys.exit(1)
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/cmd/Makefile.am b/sys/contrib/openzfs/tests/zfs-tests/cmd/Makefile.am
	index 2b965ca70009..d1c29fcd1c62 100644
	--- a/sys/contrib/openzfs/tests/zfs-tests/cmd/Makefile.am
	+++ b/sys/contrib/openzfs/tests/zfs-tests/cmd/Makefile.am
	@@ -1,37 +1,38 @@
	EXTRA_DIST = file_common.h

	SUBDIRS = \
	badsend \
	btree_test \
	chg_usr_exec \
	devname2devid \
	dir_rd_update \
	draid \
	file_check \
	file_trunc \
	file_write \
	get_diff \
	largest_file \
	libzfs_input_check \
	mkbusy \
	mkfile \
	mkfiles \
	mktree \
	mmap_exec \
	mmap_libaio \
	+ mmap_seek \
	mmapwrite \
	nvlist_to_lua \
	randwritecomp \
	readmmap \
	rename_dir \
	rm_lnkcnt_zero_file \
	send_doall \
	stride_dd \
	threadsappend

	if BUILD_LINUX
	SUBDIRS += \
	randfree_file \
	user_ns_exec \
	xattrtest
	endif
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/cmd/file_check/file_check.c b/sys/contrib/openzfs/tests/zfs-tests/cmd/file_check/file_check.c
	index 5df0ea735bfd..3d3db753f3d7 100644
	--- a/sys/contrib/openzfs/tests/zfs-tests/cmd/file_check/file_check.c
	+++ b/sys/contrib/openzfs/tests/zfs-tests/cmd/file_check/file_check.c
	@@ -1,86 +1,83 @@
	/*
	* 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"

	static unsigned char bigbuffer[BIGBUFFERSIZE];

	/*
	* Given a filename, check that the file consists entirely
	* of a particular pattern. If the pattern is not specified a
	* default will be used. For default values see file_common.h
	*/
	int
	main(int argc, char **argv)
	{
	int bigfd;
	long i, n;
	unsigned char fillchar = DATA;
	int bigbuffersize = BIGBUFFERSIZE;
	- int64_t read_count = 0;

	/*
	* Validate arguments
	*/
	if (argc < 2) {
	(void) printf("Usage: %s filename [pattern]\n",
	argv[0]);
	exit(1);
	}

	if (argv[2]) {
	fillchar = atoi(argv[2]);
	}

	/*
	* Read the file contents and check every character
	* against the supplied pattern. Abort if the
	* pattern check fails.
	*/
	if ((bigfd = open(argv[1], O_RDONLY)) == -1) {
	(void) printf("open %s failed %d\n", argv[1], errno);
	exit(1);
	}

	do {
	if ((n = read(bigfd, &bigbuffer, bigbuffersize)) == -1) {
	(void) printf("read failed (%ld), %d\n", n, errno);
	exit(errno);
	}

	for (i = 0; i < n; i++) {
	if (bigbuffer[i] != fillchar) {
	(void) printf("error %s: 0x%x != 0x%x)\n",
	argv[1], bigbuffer[i], fillchar);
	exit(1);
	}
	}
	-
	- read_count += n;
	} while (n == bigbuffersize);

	return (0);
	}
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/cmd/mmap_seek/.gitignore b/sys/contrib/openzfs/tests/zfs-tests/cmd/mmap_seek/.gitignore
	new file mode 100644
	index 000000000000..6b05a7917500
	--- /dev/null
	+++ b/sys/contrib/openzfs/tests/zfs-tests/cmd/mmap_seek/.gitignore
	@@ -0,0 +1 @@
	+/mmap_seek
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/cmd/mmap_seek/Makefile.am b/sys/contrib/openzfs/tests/zfs-tests/cmd/mmap_seek/Makefile.am
	new file mode 100644
	index 000000000000..b938931125f5
	--- /dev/null
	+++ b/sys/contrib/openzfs/tests/zfs-tests/cmd/mmap_seek/Makefile.am
	@@ -0,0 +1,6 @@
	+include $(top_srcdir)/config/Rules.am
	+
	+pkgexecdir = $(datadir)/@PACKAGE@/zfs-tests/bin
	+
	+pkgexec_PROGRAMS = mmap_seek
	+mmap_seek_SOURCES = mmap_seek.c
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/cmd/mmap_seek/mmap_seek.c b/sys/contrib/openzfs/tests/zfs-tests/cmd/mmap_seek/mmap_seek.c
	new file mode 100644
	index 000000000000..f476e1dba9a4
	--- /dev/null
	+++ b/sys/contrib/openzfs/tests/zfs-tests/cmd/mmap_seek/mmap_seek.c
	@@ -0,0 +1,147 @@
	+/*
	+ * 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) 2021 by Lawrence Livermore National Security, LLC.
	+ */
	+
	+#include <unistd.h>
	+#include <fcntl.h>
	+#include <stdio.h>
	+#include <stdlib.h>
	+#include <string.h>
	+#include <sys/mman.h>
	+#include <errno.h>
	+
	+static void
	+seek_data(int fd, off_t offset, off_t expected)
	+{
	+ off_t data_offset = lseek(fd, offset, SEEK_DATA);
	+ if (data_offset != expected) {
	+ fprintf(stderr, "lseek(fd, %d, SEEK_DATA) = %d (expected %d)\n",
	+ (int)offset, (int)data_offset, (int)expected);
	+ exit(2);
	+ }
	+}
	+
	+static void
	+seek_hole(int fd, off_t offset, off_t expected)
	+{
	+ off_t hole_offset = lseek(fd, offset, SEEK_HOLE);
	+ if (hole_offset != expected) {
	+ fprintf(stderr, "lseek(fd, %d, SEEK_HOLE) = %d (expected %d)\n",
	+ (int)offset, (int)hole_offset, (int)expected);
	+ exit(2);
	+ }
	+}
	+
	+int
	+main(int argc, char **argv)
	+{
	+ char *execname = argv[0];
	+ char *file_path = argv[1];
	+ char *buf = NULL;
	+ int err;
	+
	+ if (argc != 4) {
	+ (void) printf("usage: %s <file name> <file size> "
	+ "<block size>\n", argv[0]);
	+ exit(1);
	+ }
	+
	+ int fd = open(file_path, O_RDWR \| O_CREAT, 0666);
	+ if (fd == -1) {
	+ (void) fprintf(stderr, "%s: %s: ", execname, file_path);
	+ perror("open");
	+ exit(2);
	+ }
	+
	+ off_t file_size = atoi(argv[2]);
	+ off_t block_size = atoi(argv[3]);
	+
	+ if (block_size * 2 > file_size) {
	+ (void) fprintf(stderr, "file size must be at least "
	+ "double the block size\n");
	+ exit(2);
	+ }
	+
	+ err = ftruncate(fd, file_size);
	+ if (err == -1) {
	+ perror("ftruncate");
	+ exit(2);
	+ }
	+
	+ if ((buf = mmap(NULL, file_size, PROT_READ \| PROT_WRITE,
	+ MAP_SHARED, fd, 0)) == MAP_FAILED) {
	+ perror("mmap");
	+ exit(2);
	+ }
	+
	+ /* Verify the file is sparse and reports no data. */
	+ seek_data(fd, 0, -1);
	+
	+ /* Verify the file is reported as a hole. */
	+ seek_hole(fd, 0, 0);
	+
	+ /* Verify search beyond end of file is an error. */
	+ seek_data(fd, 2 * file_size, -1);
	+ seek_hole(fd, 2 * file_size, -1);
	+
	+ /* Dirty the first byte. */
	+ memset(buf, 'a', 1);
	+ seek_data(fd, 0, 0);
	+ seek_data(fd, block_size, -1);
	+ seek_hole(fd, 0, block_size);
	+ seek_hole(fd, block_size, block_size);
	+
	+ /* Dirty the first half of the file. */
	+ memset(buf, 'b', file_size / 2);
	+ seek_data(fd, 0, 0);
	+ seek_data(fd, block_size, block_size);
	+ seek_hole(fd, 0, P2ROUNDUP(file_size / 2, block_size));
	+ seek_hole(fd, block_size, P2ROUNDUP(file_size / 2, block_size));
	+
	+ /* Dirty the whole file. */
	+ memset(buf, 'c', file_size);
	+ seek_data(fd, 0, 0);
	+ seek_data(fd, file_size * 3 / 4,
	+ P2ROUNDUP(file_size * 3 / 4, block_size));
	+ seek_hole(fd, 0, file_size);
	+ seek_hole(fd, file_size / 2, file_size);
	+
	+ /* Punch a hole (required compression be enabled). */
	+ memset(buf + block_size, 0, block_size);
	+ seek_data(fd, 0, 0);
	+ seek_data(fd, block_size, 2 * block_size);
	+ seek_hole(fd, 0, block_size);
	+ seek_hole(fd, block_size, block_size);
	+ seek_hole(fd, 2 * block_size, file_size);
	+
	+ err = munmap(buf, file_size);
	+ if (err == -1) {
	+ perror("munmap");
	+ exit(2);
	+ }
	+
	+ close(fd);
	+
	+ return (0);
	+}
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/include/commands.cfg b/sys/contrib/openzfs/tests/zfs-tests/include/commands.cfg
	index 1ec73f25bae7..4497a6248b4b 100644
	--- a/sys/contrib/openzfs/tests/zfs-tests/include/commands.cfg
	+++ b/sys/contrib/openzfs/tests/zfs-tests/include/commands.cfg
	@@ -1,223 +1,224 @@
	#
	# Copyright (c) 2016, 2019 by Delphix. All rights reserved.
	# These variables are used by zfs-tests.sh to constrain which utilities
	# may be used by the suite. The suite will create a directory which is
	# the only element of $PATH and create symlinks from that dir to the
	# binaries listed below.
	#
	# Please keep the contents of each variable sorted for ease of reading
	# and maintenance.
	#
	export SYSTEM_FILES_COMMON='arp
	awk
	base64
	basename
	bc
	bunzip2
	bzcat
	cat
	chgrp
	chmod
	chown
	cksum
	cmp
	cp
	cpio
	cut
	date
	dd
	df
	diff
	dirname
	dmesg
	du
	echo
	egrep
	env
	expr
	false
	file
	find
	fio
	getconf
	getent
	getfacl
	grep
	gunzip
	gzip
	head
	hostname
	id
	iostat
	kill
	ksh
	ln
	logname
	ls
	mkdir
	mknod
	mktemp
	mount
	mv
	net
	od
	openssl
	pamtester
	pax
	pgrep
	ping
	pkill
	printenv
	printf
	ps
	pwd
	python
	python2
	python3
	quotaon
	readlink
	rm
	rmdir
	scp
	script
	sed
	seq
	setfacl
	sh
	sleep
	sort
	ssh
	stat
	strings
	su
	sudo
	sum
	swapoff
	swapon
	sync
	tail
	tar
	tee
	timeout
	touch
	tr
	true
	truncate
	umask
	umount
	uname
	uniq
	uuidgen
	vmstat
	wait
	wc
	which
	xargs'

	export SYSTEM_FILES_FREEBSD='chflags
	compress
	diskinfo
	dumpon
	fsck
	getextattr
	gpart
	jail
	jexec
	jls
	lsextattr
	md5
	mdconfig
	mkfifo
	newfs
	pw
	rmextattr
	setextattr
	sha256
	showmount
	swapctl
	sysctl
	uncompress'

	export SYSTEM_FILES_LINUX='attr
	bash
	blkid
	blockdev
	chattr
	dmidecode
	exportfs
	fallocate
	fdisk
	free
	getfattr
	groupadd
	groupdel
	groupmod
	hostid
	losetup
	lsattr
	lsblk
	lscpu
	lsmod
	lsscsi
	md5sum
	mkswap
	modprobe
	mpstat
	nproc
	parted
	perf
	setenforce
	setfattr
	sha256sum
	udevadm
	useradd
	userdel
	usermod'

	export ZFS_FILES='zdb
	zfs
	zhack
	zinject
	zpool
	ztest
	raidz_test
	arc_summary
	arcstat
	dbufstat
	mount.zfs
	zed
	zgenhostid
	zstream
	zfs_ids_to_path
	zpool_influxdb'

	export ZFSTEST_FILES='badsend
	btree_test
	chg_usr_exec
	devname2devid
	dir_rd_update
	draid
	file_check
	file_trunc
	file_write
	get_diff
	largest_file
	libzfs_input_check
	mkbusy
	mkfile
	mkfiles
	mktree
	mmap_exec
	mmap_libaio
	+ mmap_seek
	mmapwrite
	nvlist_to_lua
	randfree_file
	randwritecomp
	readmmap
	rename_dir
	rm_lnkcnt_zero_file
	send_doall
	threadsappend
	user_ns_exec
	xattrtest
	stride_dd'
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/include/tunables.cfg b/sys/contrib/openzfs/tests/zfs-tests/include/tunables.cfg
	index 56d430a39875..fff43e469165 100644
	--- a/sys/contrib/openzfs/tests/zfs-tests/include/tunables.cfg
	+++ b/sys/contrib/openzfs/tests/zfs-tests/include/tunables.cfg
	@@ -1,95 +1,96 @@
	# 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_SHIFT dbuf.cache_shift dbuf_cache_shift
	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
	+DMU_OFFSET_NEXT_SYNC dmu_offset_next_sync zfs_dmu_offset_next_sync
	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/bootfs/bootfs_002_neg.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/bootfs/bootfs_002_neg.ksh
	index 6a72bfcdc40c..a5bc7753e96e 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/bootfs/bootfs_002_neg.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/bootfs/bootfs_002_neg.ksh
	@@ -1,86 +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 2015 Nexenta Systems, Inc.
	#

	#
	# Copyright (c) 2012, 2016 by Delphix. All rights reserved.
	#

	#
	# Copyright (c) 2012, 2015 by Delphix. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib

	#
	# DESCRIPTION:
	#
	# Invalid datasets are rejected as boot property values
	#
	# STRATEGY:
	#
	# 1. Create a zvol
	# 2. Verify that we can't set the bootfs to that dataset
	#

	verify_runnable "global"

	function cleanup {
	- if datasetexists $TESTPOOL/vol
	- then
	- log_must zfs destroy $TESTPOOL/vol
	- fi
	- if poolexists $TESTPOOL
	- then
	- log_must zpool destroy $TESTPOOL
	- fi
	+ datasetexists $TESTPOOL/vol && destroy_dataset $TESTPOOL/vol
	+ poolexists $TESTPOOL && log_must zpool destroy $TESTPOOL
	+
	if [[ -f $VDEV ]]; then
	log_must rm -f $VDEV
	fi
	}


	zpool set 2>&1 \| grep bootfs > /dev/null
	if [ $? -ne 0 ]
	then
	log_unsupported "bootfs pool property not supported on this release."
	fi

	log_assert "Invalid datasets are rejected as boot property values"
	log_onexit cleanup

	typeset VDEV=$TESTDIR/bootfs_002_neg_a.$$.dat

	log_must mkfile 400m $VDEV
	create_pool "$TESTPOOL" "$VDEV"
	log_must zfs create -V 10m $TESTPOOL/vol
	block_device_wait

	log_mustnot zpool set bootfs=$TESTPOOL/vol $TESTPOOL

	log_pass "Invalid datasets are rejected as boot property values"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/casenorm/casenorm.kshlib b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/casenorm/casenorm.kshlib
	index cb61798d7be7..f0fe1bbaa886 100644
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/casenorm/casenorm.kshlib
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/casenorm/casenorm.kshlib
	@@ -1,131 +1,131 @@
	#
	# 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 2015 Nexenta Systems, Inc. All rights reserved.
	#

	#
	# Copyright (c) 2016 by Delphix. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/casenorm/casenorm.cfg

	function create_testfs
	{
	typeset opts=$1

	rm -rf $TESTDIR \|\| log_unresolved Could not remove $TESTDIR
	mkdir -p $TESTDIR \|\| log_unresolved Could not create $TESTDIR

	log_must zfs create $opts $TESTPOOL/$TESTFS
	log_must zfs set mountpoint=$TESTDIR $TESTPOOL/$TESTFS
	}

	function destroy_testfs
	{
	if datasetexists $TESTPOOL/$TESTFS ; then
	- log_must zfs destroy -f $TESTPOOL/$TESTFS
	+ destroy_dataset $TESTPOOL/$TESTFS -f
	rm -rf $TESTDIR \|\| log_unresolved Could not remove $TESTDIR
	fi
	}

	function create_file
	{
	typeset name=$TESTDIR/$1

	echo $name > $name
	}

	function delete_file
	{
	typeset name=$TESTDIR/$1

	rm $name >/dev/null 2>&1

	if [[ $? -ne 0 ]] ; then
	return 1
	fi

	if [[ -f $name ]] ; then
	return 2
	fi
	}

	function lookup_file
	{
	typeset name=$1

	if is_illumos; then
	zlook -l $TESTDIR $name >/dev/null 2>&1
	else
	test -f "${TESTDIR}/${name}" >/dev/null 2>&1
	fi
	}

	function lookup_file_ci
	{
	typeset name=$1

	if is_illumos; then
	zlook -il $TESTDIR $name >/dev/null 2>&1
	else
	test -f "${TESTDIR}/${name}" >/dev/null 2>&1
	fi
	}

	function lookup_any
	{
	for name in $NAMES_ALL ; do
	lookup_file $name
	if [[ $? -eq 0 ]] ; then
	return 0
	fi
	done

	return 1
	}

	function switch_norm
	{
	typeset norm=$(get_norm $1)

	if [[ $norm == "C" ]] ; then
	print "D"
	else
	print "C"
	fi
	}

	function get_norm
	{
	if [[ "${NAMES_C#*$1}" != "${NAMES_C}" ]] ; then
	print "C"
	elif [[ "${NAMES_D#*$1}" != "${NAMES_D}" ]] ; then
	print "D"
	else
	return 1
	fi
	}

	function get_case
	{
	if [[ ${NAMES_UPPER#*$1} != ${NAMES_UPPER} ]] ; then
	print "UPPER"
	elif [[ ${NAMES_LOWER#*$1} != ${NAMES_LOWER} ]] ; then
	print "LOWER"
	elif [[ ${NAMES_ORIG#*$1} != ${NAMES_ORIG} ]] ; then
	print "ORIG"
	else
	return 1
	fi
	}
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/channel_program/lua_core/tst.exists.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/channel_program/lua_core/tst.exists.ksh
	index d486c25f4487..eba01b17c80e 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/channel_program/lua_core/tst.exists.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/channel_program/lua_core/tst.exists.ksh
	@@ -1,45 +1,45 @@
	#!/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/channel_program/channel_common.kshlib

	#
	# DESCRIPTION:
	# zfs.exists should accurately report whether a dataset exists, and
	# report an error if a dataset is in another pool.

	verify_runnable "global"

	# create $TESTSNAP and $TESTCLONE
	create_snapshot
	create_clone

	function cleanup
	{
	datasetexists $TESTPOOL/$TESTFS@$TESTSNAP && \
	- log_must zfs destroy -R $TESTPOOL/$TESTFS@$TESTSNAP
	+ destroy_dataset $TESTPOOL/$TESTFS@$TESTSNAP -R
	}

	log_must_program $TESTPOOL $ZCP_ROOT/lua_core/tst.exists.zcp \
	$TESTPOOL $TESTPOOL/$TESTFS $TESTPOOL/$TESTFS@$TESTSNAP \
	$TESTPOOL/$TESTCLONE

	log_mustnot_checkerror_program "not in the target pool" \
	$TESTPOOL - <<-EOF
	return zfs.exists('rpool')
	EOF

	log_pass "zfs.exists() gives correct results"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/channel_program/lua_core/tst.return_large.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/channel_program/lua_core/tst.return_large.ksh
	index ba9c40739471..bbaeb54f59a5 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/channel_program/lua_core/tst.return_large.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/channel_program/lua_core/tst.return_large.ksh
	@@ -1,54 +1,54 @@
	#!/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) 2016, 2017 by Delphix. All rights reserved.
	#

	. $STF_SUITE/tests/functional/channel_program/channel_common.kshlib

	#
	# DESCRIPTION: Returning very large (up to the memory limit) lists should
	# function correctly.
	#

	verify_runnable "global"

	fs=$TESTPOOL/$TESTFS/testchild

	function cleanup
	{
	- datasetexists $fs && log_must zfs destroy -R $fs
	+ datasetexists $fs && destroy_dataset $fs -R
	}

	log_onexit cleanup

	log_must zfs create $fs

	#
	# Actually checking in the ~500kb expected result of this program would be
	# awful, so we just make sure it was as long as we expected.
	#
	output_lines=$(log_must zfs program $TESTPOOL \
	$ZCP_ROOT/lua_core/tst.return_large.zcp \| wc -l)

	[[ $output_lines -lt 5000 ]] &&
	log_fail "Expected return of full list but only got $output_lines lines"

	#
	# Make sure we fail if the return is over the memory limit
	#
	log_mustnot_program -m 10000 $TESTPOOL \
	$ZCP_ROOT/lua_core/tst.return_large.zcp

	log_pass "Large return values work properly"

	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/channel_program/synctask_core/tst.get_string_props.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/channel_program/synctask_core/tst.get_string_props.ksh
	index b7d784489ac8..31ae4a5717f5 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/channel_program/synctask_core/tst.get_string_props.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/channel_program/synctask_core/tst.get_string_props.ksh
	@@ -1,45 +1,45 @@
	#!/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) 2016 by Delphix. All rights reserved.
	#

	. $STF_SUITE/tests/functional/channel_program/channel_common.kshlib

	#
	# DESCRIPTION:
	# Getting string props should work correctly.
	#

	verify_runnable "global"

	fs=$TESTPOOL/testchild
	snap=$fs@$TESTSNAP
	clone=$TESTPOOL/$TESTCLONE


	function cleanup
	{
	- datasetexists $clone && log_must zfs destroy $clone
	- datasetexists $fs && log_must zfs destroy -R $fs
	+ datasetexists $clone && destroy_dataset $clone
	+ datasetexists $fs && destroy_dataset $fs -R
	}

	log_onexit cleanup

	log_must zfs create $fs
	create_snapshot $fs $TESTSNAP
	create_clone $snap $clone

	log_must_program $TESTPOOL $ZCP_ROOT/synctask_core/tst.get_string_props.zcp $fs $snap $clone

	log_pass "Getting string props should work correctly."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/channel_program/synctask_core/tst.terminate_by_signal.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/channel_program/synctask_core/tst.terminate_by_signal.ksh
	index 0a5fb804ac39..2c9014a08483 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/channel_program/synctask_core/tst.terminate_by_signal.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/channel_program/synctask_core/tst.terminate_by_signal.ksh
	@@ -1,98 +1,98 @@
	#!/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/channel_program/channel_common.kshlib

	#
	# DESCRIPTION: Execute a long-running zfs channel program and attempt to
	# cancel it by sending a signal.
	#

	verify_runnable "global"

	rootfs=$TESTPOOL/$TESTFS
	snapname=snap
	limit=50000000

	function cleanup
	{
	- datasetexists $rootfs && log_must zfs destroy -R $rootfs
	+ datasetexists $rootfs && destroy_dataset $rootfs -R
	}

	log_onexit cleanup

	#
	# Create a working set of 100 file systems
	#
	for i in {1..100}; do
	log_must zfs create "$rootfs/child$i"
	done

	#
	# Attempt to create 100 snapshots with zfs.sync.snapshot() along with some
	# time consuming efforts. We use loops of zfs.check.* (dry run operations)
	# to consume instructions before the next zfs.sync.snapshot() occurs.
	#
	# Without a signal interruption this ZCP would take several minutes and
	# generate over 30 million Lua instructions.
	#
	function chan_prog
	{
	zfs program -t $limit $TESTPOOL - $rootfs $snapname <<-EOF
	arg = ...
	fs = arg["argv"][1]
	snap = arg["argv"][2]
	for child in zfs.list.children(fs) do
	local snapname = child .. "@" .. snap
	zfs.check.snapshot(snapname)
	zfs.sync.snapshot(snapname)
	for i=1,20000,1 do
	zfs.check.snapshot(snapname)
	zfs.check.destroy(snapname)
	zfs.check.destroy(fs)
	end
	end
	return "should not have reached here"
	EOF
	}

	log_note "Executing a long-running zfs program in the background"
	chan_prog &
	CHILD=$!

	#
	# After waiting, send a kill signal to the channel program process.
	# This should stop the ZCP near a million instructions but still have
	# created some of the snapshots. Note that since the above zfs program
	# command might get wrapped, we also issue a kill to the group.
	#
	sleep 10
	log_pos pkill -P $CHILD
	log_pos kill $CHILD

	#
	# Make sure the channel program did not fully complete by enforcing
	# that not all of the snapshots were created.
	#
	snap_count=$(zfs list -t snapshot \| grep $TESTPOOL \| wc -l)
	log_note "$snap_count snapshots created by ZCP"

	if [ "$snap_count" -eq 0 ]; then
	log_fail "Channel program failed to run."
	elif [ "$snap_count" -gt 90 ]; then
	log_fail "Too many snapshots after a cancel ($snap_count)."
	else
	log_pass "Canceling a long-running channel program works."
	fi
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs/zfs_002_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs/zfs_002_pos.ksh
	index b475960c9dea..1290d888a947 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs/zfs_002_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs/zfs_002_pos.ksh
	@@ -1,123 +1,121 @@
	#!/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) 2012, 2016 by Delphix. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib

	#
	# DESCRIPTION:
	# With ZFS_ABORT set, all zfs commands should be able to abort and generate a
	# core file.
	#
	# STRATEGY:
	# 1. Create an array of zfs command
	# 2. Execute each command in the array
	# 3. Verify the command aborts and generate a core file
	#

	verify_runnable "both"

	function cleanup
	{
	unset ZFS_ABORT

	if is_freebsd && [[ -n $savedcorefile ]]; then
	sysctl kern.corefile=$savedcorefile
	fi

	if [[ -d $corepath ]]; then
	rm -rf $corepath
	fi
	for ds in $fs1 $fs $ctr; do
	- if datasetexists $ds; then
	- log_must zfs destroy -rRf $ds
	- fi
	+ datasetexists $ds && destroy_dataset $ds -rRf
	done
	}

	log_assert "With ZFS_ABORT set, all zfs commands can abort and generate a " \
	"core file."
	log_onexit cleanup

	# Preparation work for testing
	savedcorefile=""
	corepath=$TESTDIR/core
	corefile=$corepath/core.zfs
	if [[ -d $corepath ]]; then
	rm -rf $corepath
	fi
	log_must mkdir $corepath

	ctr=$TESTPOOL/$TESTCTR
	log_must zfs create $ctr

	fs=$ctr/$TESTFS
	fs1=$ctr/$TESTFS1
	snap=$fs@$TESTSNAP
	clone=$ctr/$TESTCLONE
	streamf=$corepath/s.$$

	typeset cmds=("create $fs" "list $fs" "snapshot $snap" "set snapdir=hidden $fs" \
	"get snapdir $fs" "rollback $snap" "inherit snapdir $fs" \
	"rename $fs $fs-new" "rename $fs-new $fs" "unmount $fs" \
	"mount $fs" "share $fs" "unshare $fs" "send $snap \>$streamf" \
	"receive $fs1 \<$streamf" "clone $snap $clone" "promote $clone" \
	"promote $fs" "destroy -rRf $fs")

	typeset badparams=("" "create" "destroy" "snapshot" "rollback" "clone" \
	"promote" "rename" "list -" "set" "get -" "inherit" "mount -A" \
	"unmount" "share" "unshare" "send" "receive")

	if is_linux; then
	ulimit -c unlimited
	echo "$corefile" >/proc/sys/kernel/core_pattern
	echo 0 >/proc/sys/kernel/core_uses_pid
	export ASAN_OPTIONS="abort_on_error=1:disable_coredump=0"
	elif is_freebsd; then
	ulimit -c unlimited
	savedcorefile=$(sysctl -n kern.corefile)
	log_must sysctl kern.corefile=$corepath/core.%N
	else
	log_must coreadm -p ${corepath}/core.%f
	fi

	log_must export ZFS_ABORT=yes

	for subcmd in "${cmds[@]}" "${badparams[@]}"; do
	zfs $subcmd >/dev/null 2>&1 && log_fail "$subcmd passed incorrectly."
	if [[ ! -e $corefile ]]; then
	log_fail "zfs $subcmd cannot generate core file with " \
	"ZFS_ABORT set."
	fi
	log_must rm -f $corefile
	done

	log_pass "With ZFS_ABORT set, zfs command can abort and generate core file " \
	"as expected."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_bookmark/zfs_bookmark_cliargs.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_bookmark/zfs_bookmark_cliargs.ksh
	index 10e93337abf8..3a1cddb5c64a 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_bookmark/zfs_bookmark_cliargs.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_bookmark/zfs_bookmark_cliargs.ksh
	@@ -1,238 +1,237 @@
	#!/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 2017, loli10K <ezomori.nozomu@gmail.com>. All rights reserved.
	# Copyright 2019, 2020 by Christian Schwarz. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib

	#
	# DESCRIPTION:
	# 'zfs bookmark' should work with both full and short arguments.
	#
	# STRATEGY:
	# 1. Create initial snapshot
	#
	# 2. Verify we can create a bookmark specifying snapshot and bookmark full paths
	# 3. Verify we can create a bookmark specifying the short snapshot name
	# 4. Verify we can create a bookmark specifying the short bookmark name
	# 5. Verify at least a full dataset path is required and both snapshot and
	# bookmark name must be valid
	#
	# 6. Verify we can copy a bookmark by specifying the source bookmark and new
	# bookmark full paths.
	# 7. Verify we can copy a bookmark specifying the short source name
	# 8. Verify we can copy a bookmark specifying the short new name
	# 9. Verify two short paths are not allowed, and test empty paths
	# 10. Verify we cannot copy a bookmark if the new bookmark already exists
	# 11. Verify that copying a bookmark only works if new and source name
	# have the same dataset
	#

	verify_runnable "both"

	function cleanup
	{
	- if snapexists "$DATASET@$TESTSNAP"; then
	- log_must zfs destroy "$DATASET@$TESTSNAP"
	- fi
	- if bkmarkexists "$DATASET#$TESTBM"; then
	- log_must zfs destroy "$DATASET#$TESTBM"
	- fi
	- if bkmarkexists "$DATASET#$TESTBMCOPY"; then
	- log_must zfs destroy "$DATASET#$TESTBMCOPY"
	- fi
	+ snapexists "$DATASET@$TESTSNAP" && \
	+ destroy_dataset "$DATASET@$TESTSNAP"
	+
	+ bkmarkexists "$DATASET#$TESTBM" && \
	+ destroy_dataset "$DATASET#$TESTBM"
	+
	+ bkmarkexists "$DATASET#$TESTBMCOPY" && \
	+ destroy_dataset "$DATASET#$TESTBMCOPY"
	}

	log_assert "'zfs bookmark' should work only when passed valid arguments."
	log_onexit cleanup

	DATASET="$TESTPOOL/$TESTFS"
	DATASET_TWO="$TESTPOOL/${TESTFS}_two"
	TESTSNAP='snapshot'
	TESTSNAP2='snapshot2'
	TESTBM='bookmark'
	TESTBMCOPY='bookmark_copy'


	# Create initial snapshot
	log_must zfs snapshot "$DATASET@$TESTSNAP"

	#
	# Bookmark creation tests
	#

	# Verify we can create a bookmark specifying snapshot and bookmark full paths
	log_must zfs bookmark "$DATASET@$TESTSNAP" "$DATASET#$TESTBM"
	log_must eval "bkmarkexists $DATASET#$TESTBM"
	log_must zfs destroy "$DATASET#$TESTBM"

	# Verify we can create a bookmark specifying the snapshot name
	log_must zfs bookmark "@$TESTSNAP" "$DATASET#$TESTBM"
	log_must eval "bkmarkexists $DATASET#$TESTBM"
	log_must zfs destroy "$DATASET#$TESTBM"

	# Verify we can create a bookmark specifying the bookmark name
	log_must zfs bookmark "$DATASET@$TESTSNAP" "#$TESTBM"
	log_must eval "bkmarkexists $DATASET#$TESTBM"
	log_must zfs destroy "$DATASET#$TESTBM"

	# Verify at least a full dataset path is required and both snapshot and
	# bookmark name must be valid
	log_mustnot zfs bookmark "@$TESTSNAP" "#$TESTBM"
	log_mustnot zfs bookmark "$TESTSNAP" "#$TESTBM"
	log_mustnot zfs bookmark "@$TESTSNAP" "$TESTBM"
	log_mustnot zfs bookmark "$TESTSNAP" "$TESTBM"
	log_mustnot zfs bookmark "$TESTSNAP" "$DATASET#$TESTBM"
	log_mustnot zfs bookmark "$DATASET" "$TESTBM"
	log_mustnot zfs bookmark "$DATASET@" "$TESTBM"
	log_mustnot zfs bookmark "$DATASET" "#$TESTBM"
	log_mustnot zfs bookmark "$DATASET@" "#$TESTBM"
	log_mustnot zfs bookmark "$DATASET@$TESTSNAP" "$TESTBM"
	log_mustnot zfs bookmark "@" "#$TESTBM"
	log_mustnot zfs bookmark "@" "#"
	log_mustnot zfs bookmark "@$TESTSNAP" "#"
	log_mustnot zfs bookmark "@$TESTSNAP" "$DATASET#"
	log_mustnot zfs bookmark "@$TESTSNAP" "$DATASET"
	log_mustnot zfs bookmark "$TESTSNAP" "$DATASET#"
	log_mustnot zfs bookmark "$TESTSNAP" "$DATASET"
	log_mustnot eval "bkmarkexists $DATASET#$TESTBM"

	# Verify that we can create a bookmarks on another origin filesystem
	log_must zfs clone "$DATASET@$TESTSNAP" "$DATASET_TWO"
	log_must zfs bookmark "$DATASET@$TESTSNAP" "$DATASET_TWO#$TESTBM"
	log_must eval "destroy_dataset $DATASET_TWO"

	# Verify that we can cannot create bookmarks on a non-origin filesystem
	log_must zfs create "$DATASET_TWO"
	log_mustnot_expect "source is not an ancestor of the new bookmark's dataset" zfs bookmark "$DATASET@$TESTSNAP" "$DATASET_TWO#$TESTBM"
	log_must zfs destroy "$DATASET_TWO"

	# Verify that we can create bookmarks of snapshots on the pool dataset
	log_must zfs snapshot "$TESTPOOL@$TESTSNAP"
	log_must zfs bookmark "$TESTPOOL@$TESTSNAP" "$TESTPOOL#$TESTBM"
	log_must zfs destroy "$TESTPOOL#$TESTBM"
	log_must zfs destroy "$TESTPOOL@$TESTSNAP"

	#
	# Bookmark copying tests
	#

	# create the source bookmark
	log_must zfs bookmark "$DATASET@$TESTSNAP" "$DATASET#$TESTBM"

	# Verify we can copy a bookmark by specifying the source bookmark
	# and new bookmark full paths.
	log_must eval "bkmarkexists $DATASET#$TESTBM"
	log_must zfs bookmark "$DATASET#$TESTBM" "$DATASET#$TESTBMCOPY"
	log_must eval "bkmarkexists $DATASET#$TESTBMCOPY"
	## validate destroy once (should be truly independent bookmarks)
	log_must zfs destroy "$DATASET#$TESTBM"
	log_mustnot eval "bkmarkexists $DATASET#$TESTBM"
	log_must eval "bkmarkexists $DATASET#$TESTBMCOPY"
	log_must zfs destroy "$DATASET#$TESTBMCOPY"
	log_mustnot eval "bkmarkexists $DATASET#$TESTBMCOPY"
	log_mustnot eval "bkmarkexists $DATASET#$TESTBM"
	## recreate the source bookmark
	log_must zfs bookmark "$DATASET@$TESTSNAP" "$DATASET#$TESTBM"

	# Verify we can copy a bookmark specifying the short source name
	log_must zfs bookmark "#$TESTBM" "$DATASET#$TESTBMCOPY"
	log_must eval "bkmarkexists $DATASET#$TESTBMCOPY"
	log_must zfs destroy "$DATASET#$TESTBMCOPY"

	# Verify we can copy a bookmark specifying the short bookmark name
	log_must zfs bookmark "$DATASET#$TESTBM" "#$TESTBMCOPY"
	log_must eval "bkmarkexists $DATASET#$TESTBMCOPY"
	log_must zfs destroy "$DATASET#$TESTBMCOPY"

	# Verify two short paths are not allowed, and test empty paths
	log_mustnot zfs bookmark "#$TESTBM" "#$TESTBMCOPY"
	log_mustnot zfs bookmark "#$TESTBM" "#"
	log_mustnot zfs bookmark "#" "#$TESTBMCOPY"
	log_mustnot zfs bookmark "#" "#"
	log_mustnot zfs bookmark "#" ""
	log_mustnot zfs bookmark "" "#"
	log_mustnot zfs bookmark "" ""

	# Verify that we can copy bookmarks on another origin filesystem
	log_must zfs clone "$DATASET@$TESTSNAP" "$DATASET_TWO"
	log_must zfs bookmark "$DATASET#$TESTBM" "$DATASET_TWO#$TESTBMCOPY"
	log_must zfs destroy "$DATASET_TWO"

	# Verify that we can cannot create bookmarks on another non-origin filesystem
	log_must zfs create "$DATASET_TWO"
	log_mustnot_expect "source is not an ancestor of the new bookmark's dataset" zfs bookmark "$DATASET#$TESTBM" "$DATASET_TWO#$TESTBMCOPY"
	log_must zfs destroy "$DATASET_TWO"

	# Verify that we can copy bookmarks on the pool dataset
	log_must zfs snapshot "$TESTPOOL@$TESTSNAP"
	log_must zfs bookmark "$TESTPOOL@$TESTSNAP" "$TESTPOOL#$TESTBM"
	log_must zfs bookmark "$TESTPOOL#$TESTBM" "$TESTPOOL#$TESTBMCOPY"
	log_must zfs destroy "$TESTPOOL#$TESTBM"
	log_must zfs destroy "$TESTPOOL#$TESTBMCOPY"
	log_must zfs destroy "$TESTPOOL@$TESTSNAP"

	# Verify that copied 'normal' bookmarks are independent of the source bookmark
	log_must zfs bookmark "$DATASET#$TESTBM" "$DATASET#$TESTBMCOPY"
	log_must zfs destroy "$DATASET#$TESTBM"
	log_must eval "zfs send $DATASET@$TESTSNAP > $TEST_BASE_DIR/zfstest_datastream.$$"
	log_must eval "destroy_dataset $TESTPOOL/$TESTFS/recv"
	log_must eval "zfs recv -o mountpoint=none $TESTPOOL/$TESTFS/recv < $TEST_BASE_DIR/zfstest_datastream.$$"
	log_must zfs snapshot "$DATASET@$TESTSNAP2"
	log_must eval "zfs send -i \#$TESTBMCOPY $DATASET@$TESTSNAP2 > $TEST_BASE_DIR/zfstest_datastream.$$"
	log_must eval "zfs recv $TESTPOOL/$TESTFS/recv < $TEST_BASE_DIR/zfstest_datastream.$$"
	# cleanup
	log_must eval "destroy_dataset $DATASET@$TESTSNAP2"
	log_must zfs destroy "$DATASET#$TESTBMCOPY"
	log_must zfs bookmark "$DATASET@$TESTSNAP" "$DATASET#$TESTBM"

	# Verify that copied redaction bookmarks are independent of the source bookmark
	## create redaction bookmark
	log_must zfs destroy "$DATASET#$TESTBM"
	log_must zfs destroy "$DATASET@$TESTSNAP"
	log_must eval "echo secret > $TESTDIR/secret"
	log_must zfs snapshot "$DATASET@$TESTSNAP"
	log_must eval "echo redacted > $TESTDIR/secret"
	log_must zfs snapshot "$DATASET@$TESTSNAP2" # TESTSNAP2 is the redaction snapshot
	log_must zfs list -t all -o name,createtxg,guid,mountpoint,written
	log_must zfs redact "$DATASET@$TESTSNAP" "$TESTBM" "$DATASET@$TESTSNAP2"
	# ensure our primitive for testing whether a bookmark is a redaction bookmark works
	log_must eval "zfs get all $DATASET#$TESTBM \| grep redact_snaps"
	## copy the redaction bookmark
	log_must zfs bookmark "$DATASET#$TESTBM" "#$TESTBMCOPY"
	log_mustnot eval "zfs get all $DATASET#$TESTBMCOPY \| grep redact_snaps"
	log_must eval "zfs send --redact "$TESTBMCOPY" -i $DATASET@$TESTSNAP $DATASET@$TESTSNAP2 2>&1 \| head -n 100 \| grep 'not a redaction bookmark'"
	# try the above again after destroying the source bookmark, preventive measure for future work
	log_must zfs destroy "$DATASET#$TESTBM"
	log_mustnot eval "zfs get all $DATASET#$TESTBMCOPY \| grep redact_snaps"
	log_must eval "zfs send --redact "$TESTBMCOPY" -i $DATASET@$TESTSNAP $DATASET@$TESTSNAP2 2>&1 \| head -n 100 \| grep 'not a redaction bookmark'"
	## cleanup
	log_must eval "destroy_dataset $DATASET@$TESTSNAP2"
	log_must zfs destroy "$DATASET#$TESTBMCOPY"
	log_must eval "destroy_dataset $DATASET@$TESTSNAP"
	log_must zfs snapshot "$DATASET@$TESTSNAP"
	log_must zfs bookmark "$DATASET@$TESTSNAP" "$DATASET#$TESTBM"

	log_pass "'zfs bookmark' works as expected"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_change-key/zfs_change-key.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_change-key/zfs_change-key.ksh
	index 781caae5b5c0..821abdeb32f7 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_change-key/zfs_change-key.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_change-key/zfs_change-key.ksh
	@@ -1,62 +1,62 @@
	#!/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) 2017 Datto, Inc. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/cli_root/zfs_load-key/zfs_load-key_common.kshlib

	#
	# DESCRIPTION:
	# 'zfs change-key' should change the key material.
	#
	# STRATEGY:
	# 1. Create an encrypted dataset
	# 2. Attempt to change the key
	# 3. Unmount the dataset and unload its key
	# 4. Attempt to load the old key
	# 5. Verify the key is not loaded
	# 6. Attempt to load the new key
	# 7. Verify the key is loaded
	#

	verify_runnable "both"

	function cleanup
	{
	datasetexists $TESTPOOL/$TESTFS1 && \
	- log_must zfs destroy -f $TESTPOOL/$TESTFS1
	+ destroy_dataset $TESTPOOL/$TESTFS1 -f
	}
	log_onexit cleanup

	log_assert "'zfs change-key' should change the key material"

	log_must eval "echo $PASSPHRASE1 \| zfs create -o encryption=on" \
	"-o keyformat=passphrase -o keylocation=prompt $TESTPOOL/$TESTFS1"
	log_must eval "echo $PASSPHRASE2 \| zfs change-key $TESTPOOL/$TESTFS1"

	log_must zfs unmount $TESTPOOL/$TESTFS1
	log_must zfs unload-key $TESTPOOL/$TESTFS1

	log_mustnot eval "echo $PASSPHRASE1 \| zfs load-key $TESTPOOL/$TESTFS1"
	log_must key_unavailable $TESTPOOL/$TESTFS1

	log_must eval "echo $PASSPHRASE2 \| zfs load-key $TESTPOOL/$TESTFS1"
	log_must key_available $TESTPOOL/$TESTFS1

	log_pass "'zfs change-key' changes the key material"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_change-key/zfs_change-key_child.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_change-key/zfs_change-key_child.ksh
	index a886ab8a7793..592f1eccca93 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_change-key/zfs_change-key_child.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_change-key/zfs_change-key_child.ksh
	@@ -1,91 +1,91 @@
	#!/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) 2017 Datto, Inc. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/cli_root/zfs_load-key/zfs_load-key_common.kshlib

	#
	# DESCRIPTION:
	# 'zfs change-key' should promote an encrypted child to an encryption root.
	#
	# STRATEGY:
	# 1. Create an encrypted dataset
	# 2. Create an encrypted child dataset
	# 3. Create an unencrypted child dataset
	# 4. Attempt to change the key without any flags
	# 5. Attempt to change the key specifying keylocation
	# 6. Attempt to change the key specifying keyformat
	# 7. Verify the new encryption root can unload and load its key
	# 8. Recreate the child dataset
	# 9. Attempt to change the key specifying both the keylocation and keyformat
	# 10. Verify the new encryption root can unload and load its key
	# 11. Verify the unencrytped child is still accessible normally
	#

	verify_runnable "both"

	function cleanup
	{
	datasetexists $TESTPOOL/$TESTFS1 && \
	- log_must zfs destroy -r $TESTPOOL/$TESTFS1
	+ destroy_dataset $TESTPOOL/$TESTFS1 -r
	}

	log_onexit cleanup

	log_assert "'zfs change-key' should promote an encrypted child to an" \
	"encryption root"

	log_must eval "echo $PASSPHRASE1 \| zfs create -o encryption=on" \
	"-o keyformat=passphrase -o keylocation=prompt $TESTPOOL/$TESTFS1"
	log_must zfs create $TESTPOOL/$TESTFS1/child
	log_must zfs create -o encryption=off $TESTPOOL/$TESTFS1/child2

	log_mustnot eval "echo $PASSPHRASE2 \| zfs change-key" \
	"$TESTPOOL/$TESTFS1/child"

	log_mustnot eval "echo $PASSPHRASE2 \| zfs change-key -o keylocation=prompt" \
	"$TESTPOOL/$TESTFS1/child"

	log_must eval "echo $PASSPHRASE2 \| zfs change-key -o keyformat=passphrase" \
	"$TESTPOOL/$TESTFS1/child"

	log_must zfs unmount $TESTPOOL/$TESTFS1/child
	log_must zfs unload-key $TESTPOOL/$TESTFS1/child
	log_must key_unavailable $TESTPOOL/$TESTFS1/child

	log_must eval "echo $PASSPHRASE2 \| zfs load-key $TESTPOOL/$TESTFS1/child"
	log_must key_available $TESTPOOL/$TESTFS1/child

	log_must zfs destroy $TESTPOOL/$TESTFS1/child
	log_must zfs create $TESTPOOL/$TESTFS1/child

	log_must eval "echo $PASSPHRASE2 \| zfs change-key -o keyformat=passphrase" \
	"-o keylocation=prompt $TESTPOOL/$TESTFS1/child"

	log_must zfs unmount $TESTPOOL/$TESTFS1/child
	log_must zfs unload-key $TESTPOOL/$TESTFS1/child
	log_must key_unavailable $TESTPOOL/$TESTFS1/child

	log_must eval "echo $PASSPHRASE2 \| zfs load-key $TESTPOOL/$TESTFS1/child"
	log_must key_available $TESTPOOL/$TESTFS1/child
	log_must zfs unmount $TESTPOOL/$TESTFS1/child2
	log_must zfs mount $TESTPOOL/$TESTFS1/child2

	log_pass "'zfs change-key' promotes an encrypted child to an encryption root"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_change-key/zfs_change-key_clones.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_change-key/zfs_change-key_clones.ksh
	index 497fb99c8102..70a9df618e1f 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_change-key/zfs_change-key_clones.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_change-key/zfs_change-key_clones.ksh
	@@ -1,80 +1,80 @@
	#!/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) 2017 Datto, Inc. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/cli_root/zfs_load-key/zfs_load-key_common.kshlib

	#
	# DESCRIPTION:
	# 'zfs change-key' should correctly update encryption roots with clones.
	#
	# STRATEGY:
	# 1. Create an encrypted dataset
	# 2. Create an encryption root child of the first dataset
	# 3. Clone the child encryption root twice
	# 4. Add inheriting children to the encryption root and each of the clones
	# 5. Verify the encryption roots
	# 6. Have the child encryption root inherit from its parent
	# 7. Verify the encryption root for all datasets is now the parent dataset
	#

	verify_runnable "both"

	function cleanup
	{
	datasetexists $TESTPOOL/$TESTFS1 && \
	- log_must zfs destroy -Rf $TESTPOOL/$TESTFS1
	+ destroy_dataset $TESTPOOL/$TESTFS1 -Rf
	}

	log_onexit cleanup

	log_assert "'zfs change-key' should correctly update encryption " \
	"roots with clones"

	log_must eval "echo $PASSPHRASE1 \| zfs create -o encryption=on" \
	"-o keyformat=passphrase -o keylocation=prompt $TESTPOOL/$TESTFS1"
	log_must eval "echo $PASSPHRASE2 \| zfs create -o encryption=on" \
	"-o keyformat=passphrase -o keylocation=prompt $TESTPOOL/$TESTFS1/child"
	log_must zfs snapshot $TESTPOOL/$TESTFS1/child@1
	log_must zfs clone $TESTPOOL/$TESTFS1/child@1 $TESTPOOL/$TESTFS1/clone1
	log_must zfs clone $TESTPOOL/$TESTFS1/child@1 $TESTPOOL/$TESTFS1/clone2
	log_must zfs create $TESTPOOL/$TESTFS1/child/A
	log_must zfs create $TESTPOOL/$TESTFS1/clone1/B
	log_must zfs create $TESTPOOL/$TESTFS1/clone2/C

	log_must verify_encryption_root $TESTPOOL/$TESTFS1 $TESTPOOL/$TESTFS1
	log_must verify_encryption_root $TESTPOOL/$TESTFS1/child $TESTPOOL/$TESTFS1/child
	log_must verify_encryption_root $TESTPOOL/$TESTFS1/clone1 $TESTPOOL/$TESTFS1/child
	log_must verify_encryption_root $TESTPOOL/$TESTFS1/clone2 $TESTPOOL/$TESTFS1/child
	log_must verify_encryption_root $TESTPOOL/$TESTFS1/child/A $TESTPOOL/$TESTFS1/child
	log_must verify_encryption_root $TESTPOOL/$TESTFS1/clone1/B $TESTPOOL/$TESTFS1/child
	log_must verify_encryption_root $TESTPOOL/$TESTFS1/clone2/C $TESTPOOL/$TESTFS1/child

	log_must zfs change-key -i $TESTPOOL/$TESTFS1/child

	log_must verify_encryption_root $TESTPOOL/$TESTFS1 $TESTPOOL/$TESTFS1
	log_must verify_encryption_root $TESTPOOL/$TESTFS1/child $TESTPOOL/$TESTFS1
	log_must verify_encryption_root $TESTPOOL/$TESTFS1/clone1 $TESTPOOL/$TESTFS1
	log_must verify_encryption_root $TESTPOOL/$TESTFS1/clone2 $TESTPOOL/$TESTFS1
	log_must verify_encryption_root $TESTPOOL/$TESTFS1/child/A $TESTPOOL/$TESTFS1
	log_must verify_encryption_root $TESTPOOL/$TESTFS1/clone1/B $TESTPOOL/$TESTFS1
	log_must verify_encryption_root $TESTPOOL/$TESTFS1/clone2/C $TESTPOOL/$TESTFS1

	log_pass "'zfs change-key' correctly updates encryption roots with clones"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_change-key/zfs_change-key_format.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_change-key/zfs_change-key_format.ksh
	index 6344b8d05a20..22212d72d1d6 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_change-key/zfs_change-key_format.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_change-key/zfs_change-key_format.ksh
	@@ -1,72 +1,72 @@
	#!/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) 2017 Datto, Inc. All rights reserved.
	# Copyright (c) 2019 DilOS
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/cli_root/zfs_load-key/zfs_load-key_common.kshlib

	#
	# DESCRIPTION:
	# 'zfs change-key -o' should change the key format.
	#
	# STRATEGY:
	# 1. Create an encryption dataset with a passphrase key format
	# 2. Unmount the dataset
	# 3. Verify the key format is passphrase
	# 4. Change the key format to hex
	# 5. Verify the key format is hex
	# 6. Attempt to reload the dataset's key
	# 7. Change the key format to raw
	# 8. Verify the key format is raw
	# 9. Attempt to reload the dataset's key
	#

	verify_runnable "both"

	function cleanup
	{
	datasetexists $TESTPOOL/$TESTFS1 && \
	- log_must zfs destroy -f $TESTPOOL/$TESTFS1
	+ destroy_dataset $TESTPOOL/$TESTFS1 -f
	}
	log_onexit cleanup

	log_assert "'zfs change-key -o' should change the key format"

	log_must eval "echo $PASSPHRASE \| zfs create -o encryption=on" \
	"-o keyformat=passphrase -o keylocation=prompt $TESTPOOL/$TESTFS1"
	log_must zfs unmount $TESTPOOL/$TESTFS1

	log_must verify_keyformat $TESTPOOL/$TESTFS1 "passphrase"

	log_must eval "echo $HEXKEY \| zfs change-key -o keyformat=hex" \
	"$TESTPOOL/$TESTFS1"
	log_must verify_keyformat $TESTPOOL/$TESTFS1 "hex"

	log_must zfs unload-key $TESTPOOL/$TESTFS1
	log_must eval "echo $HEXKEY \| zfs load-key $TESTPOOL/$TESTFS1"

	log_must eval "printf '%s' $RAWKEY \| zfs change-key -o keyformat=raw" \
	"$TESTPOOL/$TESTFS1"
	log_must verify_keyformat $TESTPOOL/$TESTFS1 "raw"

	log_must zfs unload-key $TESTPOOL/$TESTFS1
	log_must eval "printf '%s' $RAWKEY \| zfs load-key $TESTPOOL/$TESTFS1"

	log_pass "'zfs change-key -o' changes the key format"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_change-key/zfs_change-key_inherit.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_change-key/zfs_change-key_inherit.ksh
	index 94820c37ecc0..e9b010e912fc 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_change-key/zfs_change-key_inherit.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_change-key/zfs_change-key_inherit.ksh
	@@ -1,78 +1,78 @@
	#!/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) 2017 Datto, Inc. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/cli_root/zfs_load-key/zfs_load-key_common.kshlib

	#
	# DESCRIPTION:
	# 'zfs change-key -i' should cause a dataset to inherit its parent key
	#
	# STRATEGY:
	# 1. Create a parent encrypted dataset
	# 2. Create a child dataset as an encryption root
	# 3. Attempt to inherit the parent key
	# 4. Verify the key is inherited
	# 5. Unmount the parent and unload its key
	# 6. Verify the key is unavailable for parent and child
	# 7. Load the parent key
	# 8. Verify the key is available for parent and child
	# 9. Attempt to mount the datasets
	#

	verify_runnable "both"

	function cleanup
	{
	datasetexists $TESTPOOL/$TESTFS1 && \
	- log_must zfs destroy -r $TESTPOOL/$TESTFS1
	+ destroy_dataset $TESTPOOL/$TESTFS1 -r
	}
	log_onexit cleanup

	log_assert "'zfs change-key -i' should cause a dataset to inherit its" \
	"parent key"

	log_must eval "echo $PASSPHRASE \| zfs create -o encryption=on" \
	"-o keyformat=passphrase -o keylocation=prompt $TESTPOOL/$TESTFS1"
	log_must eval "echo $PASSPHRASE1 \| zfs create -o encryption=on" \
	"-o keyformat=passphrase -o keylocation=prompt" \
	"$TESTPOOL/$TESTFS1/child"

	log_must verify_encryption_root $TESTPOOL/$TESTFS1/child \
	"$TESTPOOL/$TESTFS1/child"

	log_must zfs change-key -i $TESTPOOL/$TESTFS1/child
	log_must verify_encryption_root $TESTPOOL/$TESTFS1/child "$TESTPOOL/$TESTFS1"

	log_must zfs unmount $TESTPOOL/$TESTFS1
	log_must zfs unload-key $TESTPOOL/$TESTFS1

	log_must key_unavailable $TESTPOOL/$TESTFS1
	log_must key_unavailable $TESTPOOL/$TESTFS1/child

	log_must eval "echo $PASSPHRASE \| zfs load-key $TESTPOOL/$TESTFS1"

	log_must key_available $TESTPOOL/$TESTFS1
	log_must key_available $TESTPOOL/$TESTFS1/child

	log_must zfs mount $TESTPOOL/$TESTFS1
	log_must zfs mount $TESTPOOL/$TESTFS1/child

	log_pass "'zfs change-key -i' causes a dataset to inherit its parent key"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_change-key/zfs_change-key_load.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_change-key/zfs_change-key_load.ksh
	index 4ed4aadfe0fa..a5a9976196e9 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_change-key/zfs_change-key_load.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_change-key/zfs_change-key_load.ksh
	@@ -1,58 +1,58 @@
	#!/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) 2017 Datto, Inc. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/cli_root/zfs_load-key/zfs_load-key_common.kshlib

	#
	# DESCRIPTION:
	# 'zfs change-key -l' should load a dataset's key to change it.
	#
	# STRATEGY:
	# 1. Create an encrypted dataset
	# 2. Unload dataset and unload its key
	# 3. Attempt to change the key
	# 4. Verify the dataset key is loaded
	# 3. Attempt to change the key
	#

	verify_runnable "both"

	function cleanup
	{
	datasetexists $TESTPOOL/$TESTFS1 && \
	- log_must zfs destroy -f $TESTPOOL/$TESTFS1
	+ destroy_dataset $TESTPOOL/$TESTFS1 -f
	}
	log_onexit cleanup

	log_assert "'zfs change-key -l' should load a dataset's key to change it"

	log_must eval "echo $PASSPHRASE > /$TESTPOOL/pkey"
	log_must zfs create -o encryption=on -o keyformat=passphrase \
	-o keylocation=file:///$TESTPOOL/pkey $TESTPOOL/$TESTFS1
	log_must zfs unmount $TESTPOOL/$TESTFS1
	log_must zfs unload-key $TESTPOOL/$TESTFS1

	log_must zfs change-key -l $TESTPOOL/$TESTFS1
	log_must key_available $TESTPOOL/$TESTFS1

	log_must zfs change-key -l $TESTPOOL/$TESTFS1

	log_pass "'zfs change-key -l' loads a dataset's key to change it"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_change-key/zfs_change-key_location.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_change-key/zfs_change-key_location.ksh
	index 5cbe34b269ba..607e2208cef4 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_change-key/zfs_change-key_location.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_change-key/zfs_change-key_location.ksh
	@@ -1,65 +1,65 @@
	#!/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) 2017 Datto, Inc. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/cli_root/zfs_load-key/zfs_load-key_common.kshlib

	#
	# DESCRIPTION:
	# 'zfs change-key -o' should change the keylocation.
	#
	# STRATEGY:
	# 1. Create an encryption dataset with a file key location
	# 2. Change the key location to 'prompt'
	# 3. Verify the key location
	# 4. Unmount the dataset and unload its key
	# 5. Attempt to load the dataset's key
	# 6. Attempt to change the key location to 'none'
	# 7. Attempt to change the key location to an invalid value
	#

	verify_runnable "both"

	function cleanup
	{
	datasetexists $TESTPOOL/$TESTFS1 && \
	- log_must zfs destroy -f $TESTPOOL/$TESTFS1
	+ destroy_dataset $TESTPOOL/$TESTFS1 -f
	}
	log_onexit cleanup

	log_assert "'zfs change-key -o' should change the keylocation"

	log_must eval "echo $PASSPHRASE > /$TESTPOOL/pkey"
	log_must zfs create -o encryption=on -o keyformat=passphrase \
	-o keylocation=file:///$TESTPOOL/pkey $TESTPOOL/$TESTFS1
	log_must verify_keylocation $TESTPOOL/$TESTFS1 "file:///$TESTPOOL/pkey"

	log_must eval "echo $PASSPHRASE1 \| zfs change-key -o keylocation=prompt" \
	"$TESTPOOL/$TESTFS1"
	log_must verify_keylocation $TESTPOOL/$TESTFS1 "prompt"

	log_must zfs unmount $TESTPOOL/$TESTFS1
	log_must zfs unload-key $TESTPOOL/$TESTFS1
	log_must eval "echo $PASSPHRASE1 \| zfs load-key $TESTPOOL/$TESTFS1"

	log_mustnot zfs change-key -o keylocation=none $TESTPOOL/$TESTFS1
	log_mustnot zfs change-key -o keylocation=foobar $TESTPOOL/$TESTFS1

	log_pass "'zfs change-key -o' changes the keylocation"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_change-key/zfs_change-key_pbkdf2iters.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_change-key/zfs_change-key_pbkdf2iters.ksh
	index b1672248be12..224fabf22620 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_change-key/zfs_change-key_pbkdf2iters.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_change-key/zfs_change-key_pbkdf2iters.ksh
	@@ -1,75 +1,75 @@
	#!/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) 2017 Datto, Inc. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/cli_root/zfs_load-key/zfs_load-key_common.kshlib

	#
	# DESCRIPTION:
	# 'zfs change-key -o' should change the pbkdf2 iterations.
	#
	# STRATEGY:
	# 1. Create an encryption dataset with 200k PBKDF2 iterations
	# 2. Unmount the dataset
	# 3. Change the PBKDF2 iterations to 150k
	# 4. Verify the PBKDF2 iterations
	# 5. Unload the dataset's key
	# 6. Attempt to load the dataset's key
	#

	verify_runnable "both"

	function verify_pbkdf2iters
	{
	typeset ds=$1
	typeset iterations=$2
	typeset iters=$(get_prop pbkdf2iters $ds)

	if [[ "$iters" != "$iterations" ]]; then
	log_fail "Expected $iterations iterations, got $iters"
	fi

	return 0
	}

	function cleanup
	{
	datasetexists $TESTPOOL/$TESTFS1 && \
	- log_must zfs destroy -f $TESTPOOL/$TESTFS1
	+ destroy_dataset $TESTPOOL/$TESTFS1 -f
	}
	log_onexit cleanup

	log_assert "'zfs change-key -o' should change the pbkdf2 iterations"

	log_must eval "echo $PASSPHRASE > /$TESTPOOL/pkey"
	log_must zfs create -o encryption=on -o keyformat=passphrase \
	-o keylocation=file:///$TESTPOOL/pkey -o pbkdf2iters=200000 \
	$TESTPOOL/$TESTFS1

	log_must zfs unmount $TESTPOOL/$TESTFS1
	log_must verify_pbkdf2iters $TESTPOOL/$TESTFS1 "200000"

	log_must zfs change-key -o pbkdf2iters=150000 $TESTPOOL/$TESTFS1
	log_must verify_pbkdf2iters $TESTPOOL/$TESTFS1 "150000"

	log_must zfs unload-key $TESTPOOL/$TESTFS1
	log_must zfs load-key $TESTPOOL/$TESTFS1

	log_pass "'zfs change-key -o' changes the pbkdf2 iterations"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_clone/zfs_clone_001_neg.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_clone/zfs_clone_001_neg.ksh
	index b83ccdf48c79..e6ffa26c0208 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_clone/zfs_clone_001_neg.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_clone/zfs_clone_001_neg.ksh
	@@ -1,126 +1,126 @@
	#!/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) 2012, 2016 by Delphix. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib

	#
	# DESCRIPTION:
	# 'zfs clone' should fail with inapplicable scenarios, including:
	# * Null arguments
	# * non-existent snapshots.
	# * invalid characters in ZFS namesapec
	# * Leading slash in the target clone name
	# * The argument contains an empty component.
	# * The pool specified in the target doesn't exist.
	# * The parent dataset of the target doesn't exist.
	# * The argument refer to a pool, not dataset.
	# * The target clone already exists.
	# * Null target clone argument.
	# * Too many arguments.
	# * Invalid record sizes.
	#
	# STRATEGY:
	# 1. Create an array of parameters
	# 2. For each parameter in the array, execute the sub-command
	# 3. Verify an error is returned.
	#

	verify_runnable "both"

	typeset target1=$TESTPOOL/$TESTFS1
	typeset target2=$TESTPOOL/$TESTCTR1/$TESTFS1
	typeset targets="$target1 $target2 $NONEXISTPOOLNAME/$TESTFS"

	set -A args "" \
	"$TESTPOOL/$TESTFS@blah $target1" "$TESTPOOL/$TESTVOL@blah $target1" \
	"$TESTPOOL/$TESTFS@blah* $target1" "$TESTPOOL/$TESTVOL@blah* $target1" \
	"$SNAPFS $target1" "$SNAPFS1 $target1" \
	"$SNAPFS /$target1" "$SNAPFS1 /$target1" \
	"$SNAPFS $TESTPOOL//$TESTFS1" "$SNAPFS1 $TESTPOOL//$TESTFS1" \
	"$SNAPFS $NONEXISTPOOLNAME/$TESTFS" "$SNAPFS1 $NONEXISTPOOLNAME/$TESTFS" \
	"$SNAPFS" "$SNAPFS1" \
	"$SNAPFS $target1 $target2" "$SNAPFS1 $target1 $target2" \
	"-o recordsize=2M $SNAPFS1 $target1" \
	"-o recordsize=128B $SNAPFS1 $target1"
	typeset -i argsnum=${#args[*]}
	typeset -i j=0
	while (( j < argsnum )); do
	args[((argsnum+j))]="-p ${args[j]}"
	((j = j + 1))
	done

	set -A moreargs "$SNAPFS $target2" "$SNAPFS1 $target2" \
	"$SNAPFS $TESTPOOL" "$SNAPFS1 $TESTPOOL" \
	"$SNAPFS $TESTPOOL/$TESTCTR" "$SNAPFS $TESTPOOL/$TESTFS" \
	"$SNAPFS1 $TESTPOOL/$TESTCTR" "$SNAPFS1 $TESTPOOL/$TESTFS"

	set -A args ${args[]} ${moreargs[]}

	function setup_all
	{
	log_note "Create snapshots and mount them..."

	for snap in $SNAPFS $SNAPFS1 ; do
	if ! snapexists $snap ; then
	log_must zfs snapshot $snap
	fi
	done

	return 0
	}

	function cleanup_all
	{
	for fs in $targets; do
	- datasetexists $fs && log_must zfs destroy -f $fs
	+ datasetexists $fs && destroy_dataset $fs -f
	done

	for snap in $SNAPFS $SNAPFS1 ; do
	- snapexists $snap && log_must zfs destroy -Rf $snap
	+ snapexists $snap && destroy_dataset $snap -Rf
	done

	return 0
	}

	log_assert "Badly-formed 'zfs clone' with inapplicable scenarios" \
	"should return an error."
	log_onexit cleanup_all

	setup_all

	typeset -i i=0
	while (( i < ${#args[*]} )); do
	log_mustnot zfs clone ${args[i]}
	((i = i + 1))
	done

	log_pass "Badly formed 'zfs clone' with inapplicable scenarios" \
	"fail as expected."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_clone/zfs_clone_002_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_clone/zfs_clone_002_pos.ksh
	index 8e69a7adcc3d..96eb3ea48d64 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_clone/zfs_clone_002_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_clone/zfs_clone_002_pos.ksh
	@@ -1,89 +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 2009 Sun Microsystems, Inc. All rights reserved.
	# Use is subject to license terms.
	#

	#
	# Copyright (c) 2012, 2016 by Delphix. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib

	#
	# DESCRIPTION:
	# 'zfs clone -p' should work as expected
	#
	# STRATEGY:
	# 1. prepare snapshots
	# 2. make sure without -p option, 'zfs clone' will fail
	# 3. with -p option, the clone can be created
	# 4. run 'zfs clone -p' again, the exit code should be zero
	#

	verify_runnable "both"

	function setup_all
	{
	log_note "Create snapshots and mount them..."

	for snap in $SNAPFS $SNAPFS1 ; do
	if ! snapexists $snap ; then
	log_must zfs snapshot $snap
	fi
	done

	return 0
	}

	function cleanup_all
	{

	- if datasetexists $TESTPOOL/notexist ; then
	- log_must zfs destroy -rRf $TESTPOOL/notexist
	- fi
	+ datasetexists $TESTPOOL/notexist && destroy_dataset $TESTPOOL/notexist -rRf

	for snap in $SNAPFS $SNAPFS1 ; do
	- if snapexists $snap ; then
	- log_must zfs destroy -Rf $snap
	- fi
	+ snapexists $snap && destroy_dataset $snap -Rf
	done

	return 0
	}

	log_assert "clone -p should work as expected."
	log_onexit cleanup_all

	setup_all

	log_must verify_opt_p_ops "clone" "fs" $SNAPFS \
	$TESTPOOL/notexist/new/clonefs$$

	if is_global_zone ; then
	log_must verify_opt_p_ops "clone" "vol" $SNAPFS1 \
	$TESTPOOL/notexist/new/clonevol$$
	fi

	log_pass "clone -p should work as expected."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_clone/zfs_clone_003_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_clone/zfs_clone_003_pos.ksh
	index 522275759880..6484de9c91a8 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_clone/zfs_clone_003_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_clone/zfs_clone_003_pos.ksh
	@@ -1,76 +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 2009 Sun Microsystems, Inc. All rights reserved.
	# Use is subject to license terms.
	#

	#
	# Copyright (c) 2012, 2016 by Delphix. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/cli_root/zfs_create/zfs_create_common.kshlib
	. $STF_SUITE/tests/functional/cli_root/zfs_create/properties.kshlib

	#
	# DESCRIPTION:
	# 'zfs clone -o property=value filesystem' can successfully create a ZFS
	# clone filesystem with correct property set.
	#
	# STRATEGY:
	# 1. Create a ZFS clone filesystem in the storage pool with -o option
	# 2. Verify the filesystem created successfully
	# 3. Verify the property is correctly set
	#

	verify_runnable "both"

	function cleanup
	{
	- if snapexists $SNAPFS ; then
	- log_must zfs destroy -Rf $SNAPFS
	- fi
	+ snapexists $SNAPFS && destroy_dataset $SNAPFS -Rf
	}

	log_onexit cleanup


	log_assert "'zfs clone -o property=value filesystem' can successfully create" \
	"a ZFS clone filesystem with correct property set."

	log_must zfs snapshot $SNAPFS

	typeset -i i=0
	while (( $i < ${#RW_FS_PROP[*]} )); do
	log_must zfs clone -o ${RW_FS_PROP[$i]} $SNAPFS $TESTPOOL/$TESTCLONE
	datasetexists $TESTPOOL/$TESTCLONE \|\| \
	log_fail "zfs clone $TESTPOOL/$TESTCLONE fail."
	propertycheck $TESTPOOL/$TESTCLONE ${RW_FS_PROP[i]} \|\| \
	log_fail "${RW_FS_PROP[i]} is failed to set."
	log_must zfs destroy -f $TESTPOOL/$TESTCLONE
	(( i = i + 1 ))
	done

	log_pass "'zfs clone -o property=value filesystem' can successfully create" \
	"a ZFS clone filesystem with correct property set."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_clone/zfs_clone_004_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_clone/zfs_clone_004_pos.ksh
	index 8d86f5501863..1c4c579f26bd 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_clone/zfs_clone_004_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_clone/zfs_clone_004_pos.ksh
	@@ -1,87 +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 2009 Sun Microsystems, Inc. All rights reserved.
	# Use is subject to license terms.
	#

	#
	# Copyright (c) 2012, 2016 by Delphix. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/cli_root/zfs_create/zfs_create_common.kshlib
	. $STF_SUITE/tests/functional/cli_root/zfs_create/properties.kshlib

	#
	# DESCRIPTION:
	# 'zfs clone -o property=value filesystem' can successfully create a ZFS
	# clone filesystem with multiple properties set.
	#
	# STRATEGY:
	# 1. Create a ZFS clone filesystem in the storage pool with multiple -o options
	# 2. Verify the filesystem created successfully
	# 3. Verify the properties are correctly set
	#

	verify_runnable "both"

	function cleanup
	{
	- if snapexists $SNAPFS ; then
	- log_must zfs destroy -Rf $SNAPFS
	- fi
	+ snapexists $SNAPFS && destroy_dataset $SNAPFS -Rf
	}

	log_onexit cleanup

	log_assert "'zfs clone -o property=value filesystem' can successfully create" \
	"a ZFS clone filesystem with multiple properties set."

	typeset -i i=0
	typeset opts=""

	log_must zfs snapshot $SNAPFS

	while (( $i < ${#RW_FS_PROP[*]} )); do
	if [[ ${RW_FS_PROP[$i]} != "checksum" ]]; then
	opts="$opts -o ${RW_FS_PROP[$i]}"
	fi
	(( i = i + 1 ))
	done

	log_must zfs clone $opts $SNAPFS $TESTPOOL/$TESTCLONE
	datasetexists $TESTPOOL/$TESTCLONE \|\| \
	log_fail "zfs create $TESTPOOL/$TESTCLONE fail."

	i=0
	while (( $i < ${#RW_FS_PROP[*]} )); do
	if [[ ${RW_FS_PROP[$i]} != "checksum" ]]; then
	propertycheck $TESTPOOL/$TESTCLONE ${RW_FS_PROP[i]} \|\| \
	log_fail "${RW_FS_PROP[i]} is failed to set."
	fi
	(( i = i + 1 ))
	done

	log_pass "'zfs clone -o property=value filesystem' can successfully create" \
	"a ZFS clone filesystem with multiple properties set."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_clone/zfs_clone_005_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_clone/zfs_clone_005_pos.ksh
	index afa8b46a6f7c..6f17b176734a 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_clone/zfs_clone_005_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_clone/zfs_clone_005_pos.ksh
	@@ -1,78 +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 2009 Sun Microsystems, Inc. All rights reserved.
	# Use is subject to license terms.
	#

	#
	# Copyright (c) 2012, 2016 by Delphix. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/cli_root/zfs_create/zfs_create_common.kshlib
	. $STF_SUITE/tests/functional/cli_root/zfs_create/properties.kshlib

	#
	# DESCRIPTION:
	# 'zfs clone -o property=value -V size volume' can successfully create a ZFS
	# clone volume with correct property set.
	#
	# STRATEGY:
	# 1. Create a ZFS clone volume in the storage pool with -o option
	# 2. Verify the volume created successfully
	# 3. Verify the property is correctly set
	#

	verify_runnable "global"

	function cleanup
	{
	- if snapexists $SNAPFS1 ; then
	- log_must zfs destroy -Rf $SNAPFS1
	- fi
	+ snapexists $SNAPFS1 && destroy_dataset $SNAPFS1 -Rf
	}

	log_onexit cleanup

	log_assert "'zfs clone -o property=value -V size volume' can successfully" \
	"create a ZFS clone volume with correct property set."

	log_must zfs snapshot $SNAPFS1
	typeset -i i=0
	while (( $i < ${#RW_VOL_CLONE_PROP[*]} )); do
	log_must zfs clone -o ${RW_VOL_CLONE_PROP[$i]} $SNAPFS1 \
	$TESTPOOL/$TESTCLONE
	block_device_wait

	datasetexists $TESTPOOL/$TESTCLONE \|\| \
	log_fail "zfs clone $TESTPOOL/$TESTCLONE fail."
	propertycheck $TESTPOOL/$TESTCLONE ${RW_VOL_CLONE_PROP[i]} \|\| \
	log_fail "${RW_VOL_CLONE_PROP[i]} is failed to set."
	log_must zfs destroy -f $TESTPOOL/$TESTCLONE

	(( i = i + 1 ))
	done

	log_pass "'zfs clone -o property=value volume' can successfully" \
	"create a ZFS clone volume with correct property set."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_clone/zfs_clone_006_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_clone/zfs_clone_006_pos.ksh
	index 2127eb117bf5..f2f7a5bcd077 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_clone/zfs_clone_006_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_clone/zfs_clone_006_pos.ksh
	@@ -1,86 +1,84 @@
	#!/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) 2012, 2016 by Delphix. All rights reserved.
	#


	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/cli_root/zfs_create/zfs_create_common.kshlib
	. $STF_SUITE/tests/functional/cli_root/zfs_create/properties.kshlib

	#
	# DESCRIPTION:
	# 'zfs clone -o property=value volume' can successfully create a ZFS
	# clone volume with multiple properties set.
	#
	# STRATEGY:
	# 1. Create a ZFS clone volume in the storage pool with -o option
	# 2. Verify the volume created successfully
	# 3. Verify the properties are correctly set
	#

	verify_runnable "global"

	function cleanup
	{
	- if snapexists $SNAPFS1 ; then
	- log_must_busy zfs destroy -Rf $SNAPFS1
	- fi
	+ snapexists $SNAPFS1 && destroy_dataset $SNAPFS1 -Rf
	}

	log_onexit cleanup

	log_assert "'zfs clone -o property=value volume' can successfully" \
	"create a ZFS clone volume with multiple correct properties set."

	typeset -i i=0
	typeset opts=""

	log_must zfs snapshot $SNAPFS1

	while (( $i < ${#RW_VOL_CLONE_PROP[*]} )); do
	if [[ ${RW_VOL_CLONE_PROP[$i]} != "checksum" ]]; then
	opts="$opts -o ${RW_VOL_CLONE_PROP[$i]}"
	fi
	(( i = i + 1 ))
	done

	log_must zfs clone $opts $SNAPFS1 $TESTPOOL/$TESTCLONE

	i=0
	while (( $i < ${#RW_VOL_CLONE_PROP[*]} )); do
	if [[ ${RW_VOL_CLONE_PROP[$i]} != "checksum" ]]; then
	propertycheck $TESTPOOL/$TESTCLONE ${RW_VOL_CLONE_PROP[i]} \|\| \
	log_fail "${RW_VOL_CLONE_PROP[i]} is failed to set."
	fi
	(( i = i + 1 ))
	done

	log_pass "'zfs clone -o property=value volume' can successfully" \
	"create a ZFS clone volume with multiple correct properties set."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_clone/zfs_clone_007_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_clone/zfs_clone_007_pos.ksh
	index 6fba72b58067..4bfb3d5f78ab 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_clone/zfs_clone_007_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_clone/zfs_clone_007_pos.ksh
	@@ -1,85 +1,83 @@
	#!/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) 2012, 2016 by Delphix. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib

	#
	# DESCRIPTION:
	# 'zfs clone -o version=' could upgrade version, but downgrade is denied.
	#
	# STRATEGY:
	# 1. Create clone with "-o version=" specified
	# 2. Verify it succeed while upgrade, but fails while the version downgraded.
	#

	ZFS_VERSION=$(zfs upgrade \| head -1 \| awk '{print $NF}' \
	\| sed -e 's/\.//g')

	verify_runnable "both"

	function cleanup
	{
	- if snapexists $SNAPFS ; then
	- log_must zfs destroy -Rf $SNAPFS
	- fi
	+ snapexists $SNAPFS && destroy_dataset $SNAPFS -Rf
	}

	log_onexit cleanup

	log_assert "'zfs clone -o version=' could upgrade version," \
	"but downgrade is denied."

	log_must zfs snapshot $SNAPFS

	typeset -i ver

	if (( ZFS_TEST_VERSION == 0 )) ; then
	(( ZFS_TEST_VERSION = ZFS_VERSION ))
	fi

	(( ver = ZFS_TEST_VERSION ))
	while (( ver <= ZFS_VERSION )); do
	log_must zfs clone -o version=$ver $SNAPFS $TESTPOOL/$TESTCLONE
	cleanup
	(( ver = ver + 1 ))
	done

	(( ver = 0 ))
	while (( ver < ZFS_TEST_VERSION )); do
	log_mustnot zfs clone -o version=$ver \
	$SNAPFS $TESTPOOL/$TESTCLONE
	log_mustnot datasetexists $TESTPOOL/$TESTCLONE
	cleanup
	(( ver = ver + 1 ))
	done

	log_pass "'zfs clone -o version=' could upgrade version," \
	"but downgrade is denied."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_clone/zfs_clone_008_neg.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_clone/zfs_clone_008_neg.ksh
	index 8e306fd445ea..2f2b0ca18d64 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_clone/zfs_clone_008_neg.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_clone/zfs_clone_008_neg.ksh
	@@ -1,80 +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 2009 Sun Microsystems, Inc. All rights reserved.
	# Use is subject to license terms.
	#

	#
	# Copyright (c) 2012, 2016 by Delphix. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/cli_root/zfs_create/properties.kshlib

	#
	# DESCRIPTION:
	# 'zfs clone -o <filesystem>' fails with bad <filesystem> arguments, including:
	# *Same property set multiple times via '-o property=value'
	# *Volume's property set on filesystem
	#
	# STRATEGY:
	# 1. Create an array of <filesystem> arguments
	# 2. Execute 'zfs clone -o <filesystem>' with each argument
	# 3. Verify an error is returned.
	#

	verify_runnable "both"

	function cleanup
	{
	- if snapexists $SNAPFS ; then
	- log_must zfs destroy -Rf $SNAPFS
	- fi
	+ snapexists $SNAPFS && destroy_dataset $SNAPFS -Rf
	}

	log_onexit cleanup

	log_assert "Verify 'zfs clone -o <filesystem>' fails with bad <filesystem> argument."

	log_must zfs snapshot $SNAPFS

	typeset -i i=0
	while (( $i < ${#RW_FS_PROP[*]} )); do
	log_mustnot zfs clone -o ${RW_FS_PROP[i]} -o ${RW_FS_PROP[i]} \
	$SNAPFS $TESTPOOL/$TESTCLONE
	log_mustnot zfs clone -p -o ${RW_FS_PROP[i]} -o ${RW_FS_PROP[i]} \
	$SNAPFS $TESTPOOL/$TESTCLONE
	((i = i + 1))
	done

	i=0
	while (( $i < ${#VOL_ONLY_PROP[*]} )); do
	log_mustnot zfs clone -o ${VOL_ONLY_PROP[i]} \
	$SNAPFS $TESTPOOL/$TESTCLONE
	log_mustnot zfs clone -p -o ${VOL_ONLY_PROP[i]} \
	$SNAPFS $TESTPOOL/$TESTCLONE
	((i = i + 1))
	done

	log_pass "'zfs clone -o <filesystem>' fails with bad <filesystem> argument."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_clone/zfs_clone_009_neg.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_clone/zfs_clone_009_neg.ksh
	index 030c6af7ae68..6cdf5717fa92 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_clone/zfs_clone_009_neg.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_clone/zfs_clone_009_neg.ksh
	@@ -1,80 +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 2009 Sun Microsystems, Inc. All rights reserved.
	# Use is subject to license terms.
	#

	#
	# Copyright (c) 2012, 2016 by Delphix. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/cli_root/zfs_create/properties.kshlib

	#
	# DESCRIPTION:
	# 'zfs clone -o <volume>' fails with badly formed arguments,including:
	# *Same property set multiple times via '-o property=value'
	# *Filesystems's property set on volume
	#
	# STRATEGY:
	# 1. Create an array of badly formed arguments
	# 2. For each argument, execute 'zfs clone -o <volume>'
	# 3. Verify an error is returned.
	#

	verify_runnable "global"

	function cleanup
	{
	- if snapexists $SNAPFS1 ; then
	- log_must zfs destroy -Rf $SNAPFS1
	- fi
	+ snapexists $SNAPFS1 && destroy_dataset $SNAPFS1 -Rf
	}

	log_onexit cleanup

	log_assert "Verify 'zfs clone -o <volume>' fails with bad <volume> argument."

	log_must zfs snapshot $SNAPFS1

	typeset -i i=0
	while (( $i < ${#RW_VOL_PROP[*]} )); do
	log_mustnot zfs clone -o ${RW_VOL_PROP[i]} -o ${RW_VOL_PROP[i]} \
	$SNAPFS1 $TESTPOOL/$TESTCLONE
	log_mustnot zfs clone -p -o ${RW_VOL_PROP[i]} -o ${RW_VOL_PROP[i]} \
	$SNAPFS1 $TESTPOOL/$TESTCLONE
	((i = i + 1))
	done

	i=0
	while (( $i < ${#FS_ONLY_PROP[*]} )); do
	log_mustnot zfs clone -o ${FS_ONLY_PROP[i]} \
	$SNAPFS1 $TESTPOOL/$TESTCLONE
	log_mustnot zfs clone -p -o ${FS_ONLY_PROP[i]} \
	$SNAPFS1 $TESTPOOL/$TESTCLONE
	((i = i + 1))
	done

	log_pass "Verify 'zfs clone -o <volume>' fails with bad <volume> argument."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_clone/zfs_clone_010_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_clone/zfs_clone_010_pos.ksh
	index dcf80095db28..13f5418d4bf5 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_clone/zfs_clone_010_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_clone/zfs_clone_010_pos.ksh
	@@ -1,229 +1,229 @@
	#!/bin/ksh
	#
	# 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) 2012, 2016 by Delphix. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib

	#
	# DESCRIPTION:
	# Verify 'zfs list -t all -o name,origin,clones' prints the correct
	# clone information
	#
	# STRATEGY:
	# 1. Create datasets
	# 2. Create recursive snapshots and their clones
	# 3. Verify zfs clones property displays right information for different
	# cases
	#

	verify_runnable "both"

	function local_cleanup
	{
	typeset -i i=1
	for ds in $datasets; do
	datasetexists $ds/$TESTCLONE.$i && \
	- log_must zfs destroy -rf $ds/$TESTCLONE.$i
	- datasetexists $ds && log_must zfs destroy -Rf $ds
	+ destroy_dataset $ds/$TESTCLONE.$i -rf
	+ datasetexists $ds && destroy_dataset $ds -Rf
	((i=i+1))
	done
	}

	# Set up filesystem with clones
	function setup_ds
	{
	typeset -i i=1
	# create nested datasets
	log_must zfs create -p $TESTPOOL/$TESTFS1/$TESTFS2/$TESTFS3

	# verify dataset creation
	for ds in $datasets; do
	datasetexists $ds \|\| log_fail "Create $ds dataset fail."
	done

	# create recursive nested snapshot
	log_must zfs snapshot -r $TESTPOOL/$TESTFS1@snap
	for ds in $datasets; do
	datasetexists $ds@snap \|\| \
	log_fail "Create $ds@snap snapshot fail."
	done
	for ds in $datasets; do
	for fs in $datasets; do
	log_must zfs clone $ds@snap $fs/$TESTCLONE.$i
	done
	((i=i+1))
	done
	}

	# Verify clone list
	function verify_clones
	{
	typeset -i no_clones=$1
	typeset unexpected=$2
	typeset clone_snap=$3
	typeset -i i=1
	for ds in $datasets; do
	if [[ -n $clone_snap ]]; then
	clone_snap=/$TESTCLONE.$i
	fi
	snapshot=$(echo "$names" \| grep $ds$clone_snap@snap)
	actual_clone=$(zfs list -t all -o clones $snapshot \| tail -1)
	save=$IFS
	IFS=','
	typeset -a clones=()
	for token in $actual_clone; do
	clones=( "${clones[@]}" "$token" )
	done
	IFS=$save
	[[ ${#clones[*]} -ne $no_clones ]] && \
	log_fail "$snapshot has unexpected number of clones" \
	" ${#clones[*]}"
	expected_clone=""
	unexpected_clone=""
	if [[ $unexpected -eq 1 ]]; then
	for fs in $datasets; do
	if [[ $fs == $ds ]]; then
	if [[ -z $clone_snap ]]; then
	unexpected_clone=$fs/$TESTCLONE.$i
	(for match in ${clones[@]};do
	[[ $match != $unexpected_clone ]] && \
	exit 0; done) \|\| log_fail \
	"Unexpected clones of the snapshot"
	else
	expected_clone=$fs
	unexpected_clone=$fs/$TESTCLONE.$i
	(for match in ${clones[@]};do
	[[ $match == $expected_clone ]] && \
	[[ $match != $unexpected_clone ]] \
	&& exit 0; done) \|\| log_fail \
	"Unexpected clones of the snapshot"
	fi
	else
	expected_clone=$fs/$TESTCLONE.$i
	(for match in ${clones[@]};do
	[[ $match == $expected_clone ]] && \
	exit 0; done) \|\| log_fail \
	"Unexpected clones of the snapshot"
	fi
	done
	else
	for fs in $datasets; do
	expected_clone=$fs/$TESTCLONE.$i
	(for match in ${clones[@]};do
	[[ $match == $expected_clone ]] && exit 0; \
	done) \|\| log_fail "Unexpected clones" \
	" of the snapshot"
	done
	fi
	((i=i+1))
	done
	}


	log_onexit local_cleanup
	datasets="$TESTPOOL/$TESTFS1 $TESTPOOL/$TESTFS1/$TESTFS2
	$TESTPOOL/$TESTFS1/$TESTFS2/$TESTFS3"

	typeset -a d_clones
	typeset -a deferred_snaps
	typeset -i i
	log_must setup_ds

	log_note "Verify zfs clone property for multiple clones"
	names=$(zfs list -rt all -o name $TESTPOOL)
	log_must verify_clones 3 0

	log_note "verify clone property for clone deletion"
	i=1
	for ds in $datasets; do
	log_must zfs destroy $ds/$TESTCLONE.$i
	((i=i+1))
	done
	names=$(zfs list -rt all -o name $TESTPOOL)
	log_must verify_clones 2 1

	log_must local_cleanup
	log_must setup_ds

	log_note "verify zfs deferred destroy on clones property"
	names=$(zfs list -rt all -o name $TESTPOOL)
	for ds in $datasets; do
	log_must zfs destroy -d $ds@snap
	deferred_snaps=( "${deferred_snaps[@]}" "$ds@snap" )
	done
	log_must verify_clones 3 0

	log_note "verify zfs deferred destroy by destroying clones on clones property"
	d_clones=()
	i=1
	for ds in $datasets; do
	for fs in $datasets; do
	log_must zfs destroy $fs/$TESTCLONE.$i
	d_clones=( "${d_clones[@]}" "$fs/$TESTCLONE.$i" )
	done
	((i=i+1))
	done
	names=$(zfs list -rtall -o name $TESTPOOL)
	for snap in ${deferred_snaps[@]}; do
	status=$(echo "$names" \| grep $snap)
	[[ -z $status ]] \|\| \
	log_fail "$snap exist after deferred destroy"
	done
	for dclone in ${d_clones[@]}; do
	log_note "D CLONE = $dclone"
	status=$(echo "$names" \| grep $dclone)
	[[ -z $status ]] \|\| \
	log_fail "$dclone exist after deferred destroy"
	done

	log_must local_cleanup
	log_must setup_ds
	log_note "verify clone property for zfs promote"
	i=1
	for ds in $datasets; do
	log_must zfs promote $ds/$TESTCLONE.$i
	((i=i+1))
	done
	names=$(zfs list -rt all -o name,clones $TESTPOOL)
	log_must verify_clones 3 1 $TESTCLONE
	for ds in $datasets; do
	log_must zfs promote $ds
	done
	log_must local_cleanup

	log_note "verify clone list truncated correctly"
	fs=$TESTPOOL/$TESTFS1
	xs=""; for i in {1..200}; do xs+="x"; done
	if is_linux; then
	ZFS_MAXPROPLEN=4096
	else
	ZFS_MAXPROPLEN=1024
	fi
	log_must zfs create $fs
	log_must zfs snapshot $fs@snap
	for (( i = 1; i <= (ZFS_MAXPROPLEN / 200 + 1); i++ )); do
	log_must zfs clone ${fs}@snap ${fs}/${TESTCLONE}${xs}.${i}
	done
	clone_list=$(zfs list -o clones $fs@snap)
	char_count=$(echo "$clone_list" \| tail -1 \| wc \| awk '{print $3}')
	[[ $char_count -eq $ZFS_MAXPROPLEN ]] \|\| \
	log_fail "Clone list not truncated correctly. Unexpected character count" \
	"$char_count"

	log_pass "'zfs list -o name,origin,clones prints the correct clone information."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_clone/zfs_clone_encrypted.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_clone/zfs_clone_encrypted.ksh
	index 86f335bde2a0..1f07b9eb03bc 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_clone/zfs_clone_encrypted.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_clone/zfs_clone_encrypted.ksh
	@@ -1,83 +1,83 @@
	#!/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) 2017 Datto, Inc. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/cli_root/zfs_load-key/zfs_load-key_common.kshlib

	#
	# DESCRIPTION:
	# 'zfs clone' should create encrypted clones of encrypted datasets
	#
	# STRATEGY:
	# 1. Create an encrypted dataset
	# 2. Create a snapshot of the dataset
	# 3. Attempt to clone the snapshot as an unencrypted dataset
	# 4. Attempt to clone the snapshot with a new key
	# 5. Attempt to clone the snapshot as a child of an unencrypted dataset
	# 6. Attempt to clone the snapshot as a child of an encrypted dataset
	# 7. Verify the encryption root of the datasets
	# 8. Unmount all datasets and unload their keys
	# 9. Attempt to load the encryption root's key
	# 10. Verify each dataset's key is loaded
	# 11. Attempt to mount each dataset
	#

	verify_runnable "both"

	function cleanup
	{
	datasetexists $TESTPOOL/$TESTFS2 && \
	- log_must zfs destroy -f $TESTPOOL/$TESTFS2
	+ destroy_dataset $TESTPOOL/$TESTFS2 -f
	datasetexists $TESTPOOL/$TESTFS1 && \
	- log_must zfs destroy -r $TESTPOOL/$TESTFS1
	+ destroy_dataset $TESTPOOL/$TESTFS1 -r
	}
	log_onexit cleanup

	log_assert "'zfs clone' should create encrypted clones of encrypted datasets"

	log_must eval "echo $PASSPHRASE \| zfs create -o encryption=on" \
	"-o keyformat=passphrase -o keylocation=prompt $TESTPOOL/$TESTFS1"
	log_must zfs snapshot $TESTPOOL/$TESTFS1@now

	log_mustnot zfs clone -o encryption=off $TESTPOOL/$TESTFS1@now \
	$TESTPOOL/$TESTFS2
	log_mustnot eval "echo $PASSPHRASE1 \| zfs clone -o keyformat=passphrase" \
	"$TESTPOOL/$TESTFS1@now $TESTPOOL/$TESTFS2"
	log_must zfs clone $TESTPOOL/$TESTFS1@now $TESTPOOL/$TESTFS2
	log_must zfs clone $TESTPOOL/$TESTFS1@now $TESTPOOL/$TESTFS1/child

	log_must verify_encryption_root $TESTPOOL/$TESTFS2 $TESTPOOL/$TESTFS1
	log_must verify_encryption_root $TESTPOOL/$TESTFS1/child $TESTPOOL/$TESTFS1

	log_must zfs unmount $TESTPOOL/$TESTFS1
	log_must zfs unmount $TESTPOOL/$TESTFS2
	log_must zfs unload-key -a

	log_must eval "echo $PASSPHRASE \| zfs load-key $TESTPOOL/$TESTFS1"

	log_must key_available $TESTPOOL/$TESTFS1
	log_must key_available $TESTPOOL/$TESTFS1/child
	log_must key_available $TESTPOOL/$TESTFS2

	log_must zfs mount $TESTPOOL/$TESTFS1
	log_must zfs mount $TESTPOOL/$TESTFS1/child
	log_must zfs mount $TESTPOOL/$TESTFS2

	log_pass "'zfs clone' creates encrypted clones of encrypted datasets"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_copies/zfs_copies_001_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_copies/zfs_copies_001_pos.ksh
	index 2ed881a36706..672692b59e42 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_copies/zfs_copies_001_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_copies/zfs_copies_001_pos.ksh
	@@ -1,116 +1,114 @@
	#!/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.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/cli_root/zfs_copies/zfs_copies.kshlib

	#
	# DESCRIPTION:
	# Verify "copies" property can be correctly set as 1,2 and 3 and different
	# filesystem can have different value of "copies" property within the same pool.
	#
	# STRATEGY:
	# 1. Create different filesystems with copies set as 1,2,3;
	# 2. Verify that the "copies" property has been set correctly
	#

	verify_runnable "both"

	function cleanup
	{
	typeset ds

	for ds in $fs1 $fs2 $vol1 $vol2; do
	- if datasetexists $ds; then
	- log_must zfs destroy $ds
	- fi
	+ datasetexists $ds && destroy_dataset $ds
	done
	}

	log_assert "Verify 'copies' property with correct arguments works or not."
	log_onexit cleanup

	fs=$TESTPOOL/$TESTFS
	fs1=$TESTPOOL/$TESTFS1
	fs2=$TESTPOOL/$TESTFS2
	vol=$TESTPOOL/$TESTVOL
	vol1=$TESTPOOL/$TESTVOL1
	vol2=$TESTPOOL/$TESTVOL2

	#
	# Check the default value for copies property
	#
	for ds in $fs $vol; do
	cmp_prop $ds 1
	done

	for val in 1 2 3; do
	log_must zfs create -o copies=$val $fs1
	if is_global_zone; then
	log_must zfs create -V $VOLSIZE -o copies=$val $vol1
	block_device_wait
	else
	log_must zfs create -o copies=$val $vol1
	fi
	for ds in $fs1 $vol1; do
	cmp_prop $ds $val
	done

	for val2 in 3 2 1; do
	log_must zfs create -o copies=$val2 $fs2
	if is_global_zone; then
	log_must zfs create -V $VOLSIZE -o copies=$val2 $vol2
	block_device_wait
	else
	log_must zfs create -o copies=$val2 $vol2
	fi
	for ds in $fs2 $vol2; do
	cmp_prop $ds $val2
	- log_must zfs destroy $ds
	+ destroy_dataset $ds
	block_device_wait
	done
	done

	for ds in $fs1 $vol1; do
	- log_must zfs destroy $ds
	+ destroy_dataset $ds
	block_device_wait
	done

	done

	for val in 3 2 1; do
	for ds in $fs $vol; do
	log_must zfs set copies=$val $ds
	cmp_prop $ds $val
	done
	done

	log_pass "'copies' property with correct arguments works as expected. "
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_copies/zfs_copies_002_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_copies/zfs_copies_002_pos.ksh
	index 6e293ca63829..b644fcae3cf8 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_copies/zfs_copies_002_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_copies/zfs_copies_002_pos.ksh
	@@ -1,119 +1,118 @@
	#!/bin/ksh
	#
	# 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.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/cli_root/zfs_copies/zfs_copies.kshlib

	#
	# DESCRIPTION:
	# Verify that the space used by multiple copies is charged correctly
	#
	# STRATEGY:
	# 1. Create filesystems with copies set as 2,3 respectively;
	# 2. Copy specified size data into each filesystem;
	# 3. Verify that the space is charged as expected with zfs list, ls -s, df(1m),
	# du(1) commands;
	#

	verify_runnable "both"

	function cleanup
	{
	typeset val

	for val in 1 2 3; do
	- if datasetexists $TESTPOOL/fs_$val; then
	- log_must zfs destroy $TESTPOOL/fs_$val
	- fi
	+ datasetexists $TESTPOOL/fs_$val && \
	+ destroy_dataset $TESTPOOL/fs_$val
	done
	}

	log_assert "Verify that the space used by multiple copies is charged correctly."
	log_onexit cleanup

	for val in 1 2 3; do
	log_must zfs create -o copies=$val $TESTPOOL/fs_$val

	log_must mkfile $FILESIZE /$TESTPOOL/fs_$val/$FILE
	done

	#
	# Sync up the filesystem
	#
	sync

	#
	# Verify 'zfs list' can correctly list the space charged
	#
	log_note "Verify 'zfs list' can correctly list the space charged."
	fsize=${FILESIZE%[m\|M]}
	for val in 1 2 3; do
	used=$(get_prop used $TESTPOOL/fs_$val)
	check_used $used $val
	done

	log_note "Verify 'ls -s' can correctly list the space charged."
	if is_linux \|\| is_freebsd; then
	blksize=1024
	else
	blksize=512
	fi
	for val in 1 2 3; do
	blks=`ls -ls /$TESTPOOL/fs_$val/$FILE \| awk '{print $1}'`
	(( used = blks * $blksize )) # bytes
	check_used $used $val
	done

	log_note "Verify df(1) can correctly display the space charged."
	for val in 1 2 3; do
	if is_freebsd; then
	used=`df -m /$TESTPOOL/fs_$val \| grep $TESTPOOL/fs_$val \
	\| awk -v fs=fs_$val '$4 ~ fs {print $3}'`
	else
	used=`df -F zfs -k /$TESTPOOL/fs_$val/$FILE \| grep $TESTPOOL/fs_$val \
	\| awk '{print $3}'`
	(( used = used * 1024 )) # kb -> bytes
	fi
	check_used $used $val
	done

	log_note "Verify du(1) can correctly display the space charged."
	for val in 1 2 3; do
	if is_freebsd; then
	used=`du -h /$TESTPOOL/fs_$val/$FILE \| awk '{print $1}'`
	else
	used=`du -k /$TESTPOOL/fs_$val/$FILE \| awk '{print $1}'`
	(( used = used * 1024 )) # kb -> bytes
	fi
	check_used $used $val
	done

	log_pass "The space used by multiple copies is charged correctly as expected. "
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_copies/zfs_copies_003_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_copies/zfs_copies_003_pos.ksh
	index 98420cb7f2ab..94e72bce4e67 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_copies/zfs_copies_003_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_copies/zfs_copies_003_pos.ksh
	@@ -1,68 +1,66 @@
	#!/bin/ksh
	#
	# 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.
	#

	. $STF_SUITE/tests/functional/cli_root/zfs_copies/zfs_copies.kshlib

	#
	# DESCRIPTION:
	# Verify that the volume space used by multiple copies is charged correctly
	#
	# STRATEGY:
	# 1. Create volume;
	# 2. Create ZFS filesystem based on the volume;
	# 3. Set the copies property of volume to 1,2 or 3;
	# 4. Copy specified size data into each filesystem;
	# 5. Verify that the volume space is charged as expected.
	#

	verify_runnable "global"

	function cleanup
	{
	if poolexists $TESTPOOL1; then
	destroy_pool $TESTPOOL1
	fi

	- if datasetexists $vol; then
	- log_must zfs destroy $vol
	- fi
	+ datasetexists $vol && destroy_dataset $vol
	}

	log_assert "Verify that ZFS volume space used by multiple copies is charged correctly."
	log_onexit cleanup
	vol=$TESTPOOL/$TESTVOL1


	for val in 1 2 3; do
	do_vol_test zfs $val
	done

	log_pass "The volume space used by multiple copies is charged correctly as expected. "
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_copies/zfs_copies_006_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_copies/zfs_copies_006_pos.ksh
	index 4a3ef76de763..6dc9306b33ef 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_copies/zfs_copies_006_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_copies/zfs_copies_006_pos.ksh
	@@ -1,77 +1,75 @@
	#!/bin/ksh
	#
	# 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) 2016 by Delphix. All rights reserved.
	#

	. $STF_SUITE/tests/functional/cli_root/zfs_copies/zfs_copies.kshlib

	#
	# DESCRIPTION:
	# Verify that the volume space used by multiple copies is charged correctly
	#
	# STRATEGY:
	# 1. Create volume
	# 2. Create UFS filesystem based on the volume
	# 3. Set the copies property of volume to 1,2 or 3
	# 4. Copy specified size data into each filesystem
	# 5. Verify that the volume space is charged as expected
	#

	verify_runnable "global"

	function cleanup
	{
	if ismounted $mntp $NEWFS_DEFAULT_FS ; then
	log_must umount $mntp
	fi

	- if datasetexists $vol; then
	- log_must zfs destroy $vol
	- fi
	+ datasetexists $vol && destroy_dataset $vol

	if [[ -d $mntp ]]; then
	rm -rf $mntp
	fi
	}


	log_assert "Verify that ZFS volume space used by multiple copies is charged correctly."
	log_onexit cleanup
	mntp=$FS_MNTPOINT
	vol=$TESTPOOL/$TESTVOL1

	if [[ ! -d $mntp ]]; then
	mkdir -p $mntp
	fi

	for copies in 1 2 3; do
	do_vol_test $NEWFS_DEFAULT_FS $copies $mntp
	done

	log_pass "The volume space used by multiple copies is charged correctly as expected. "
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_create/zfs_create_001_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_create/zfs_create_001_pos.ksh
	index d0807ac8d176..f74b2c9816f3 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_create/zfs_create_001_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_create/zfs_create_001_pos.ksh
	@@ -1,77 +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 2007 Sun Microsystems, Inc. All rights reserved.
	# Use is subject to license terms.
	#

	#
	# Copyright (c) 2016 by Delphix. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib

	#
	# DESCRIPTION:
	# 'zfs create <filesystem>' can create a ZFS filesystem in the namespace.
	#
	# STRATEGY:
	# 1. Create a ZFS filesystem in the storage pool
	# 2. Verify the filesystem created successfully
	#

	verify_runnable "both"


	function cleanup
	{
	typeset -i i=0
	while (( $i < ${#datasets[*]} )); do
	datasetexists ${datasets[$i]} && \
	- log_must zfs destroy -f ${datasets[$i]}
	+ destroy_dataset ${datasets[$i]} -f
	((i = i + 1))
	done

	zfs destroy -f "$TESTPOOL/with a space"
	}

	log_onexit cleanup

	set -A datasets "$TESTPOOL/$TESTFS1" "$TESTPOOL/$LONGFSNAME" "$TESTPOOL/..." \
	"$TESTPOOL/_1234_"

	log_assert "'zfs create <filesystem>' can create a ZFS filesystem in the namespace."

	typeset -i i=0
	while (( $i < ${#datasets[*]} )); do
	log_must zfs create ${datasets[$i]}
	datasetexists ${datasets[$i]} \|\| \
	log_fail "zfs create ${datasets[$i]} fail."
	((i = i + 1))
	done

	log_must zfs create "$TESTPOOL/with a space"
	log_must zfs unmount "$TESTPOOL/with a space"
	log_must zfs mount "$TESTPOOL/with a space"

	log_pass "'zfs create <filesystem>' works as expected."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_create/zfs_create_003_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_create/zfs_create_003_pos.ksh
	index 2906e32dab8c..120de10281db 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_create/zfs_create_003_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_create/zfs_create_003_pos.ksh
	@@ -1,69 +1,68 @@
	#!/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) 2012, 2016 by Delphix. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/cli_root/zfs_create/zfs_create.cfg

	#
	# DESCRIPTION:
	# 'zfs create [-b <blocksize>] -V <size> <volume>' can create a volume
	# with specified blocksize, which is power of 2 between 512 - 128k.
	#
	# STRATEGY:
	# 1. Create a volume with blocksize in the storage pool
	# 2. Verify the volume created successfully
	#

	verify_runnable "global"

	function cleanup
	{
	- datasetexists $vol && \
	- log_must zfs destroy -f $vol
	+ datasetexists $vol && destroy_dataset $vol -f
	}

	log_assert "Verify creating volume with specified blocksize works."
	log_onexit cleanup

	set -A options "" "-b 1k" "-b 1K" "-b 1024" "-b 1024b"
	vol=$TESTPOOL/$TESTVOL

	typeset -i i=0
	while (( i < ${#options[*]} )); do
	log_must zfs create ${options[i]} -V $VOLSIZE $vol
	datasetexists $vol \|\| \
	log_fail "zfs create ${options[i]} -V $VOLSIZE $vol fail."

	log_must_busy zfs destroy -f $vol
	((i = i + 1))
	done

	log_pass "'zfs create [-b <blocksize>] -V <size> <volume>' works as expected."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_create/zfs_create_004_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_create/zfs_create_004_pos.ksh
	index 200b4a091567..9e69366c8793 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_create/zfs_create_004_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_create/zfs_create_004_pos.ksh
	@@ -1,73 +1,72 @@
	#!/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.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/cli_root/zfs_create/zfs_create_common.kshlib
	. $STF_SUITE/tests/functional/cli_root/zfs_create/properties.kshlib

	#
	# DESCRIPTION:
	# 'zfs create -o property=value filesystem' can successfully create a ZFS
	# filesystem with correct property set.
	#
	# STRATEGY:
	# 1. Create a ZFS filesystem in the storage pool with -o option
	# 2. Verify the filesystem created successfully
	# 3. Verify the property is correctly set
	#

	verify_runnable "both"

	function cleanup
	{
	- datasetexists $TESTPOOL/$TESTFS1 && \
	- log_must zfs destroy -f $TESTPOOL/$TESTFS1
	+ datasetexists $TESTPOOL/$TESTFS1 && destroy_dataset $TESTPOOL/$TESTFS1 -f
	}

	log_onexit cleanup


	log_assert "'zfs create -o property=value filesystem' can successfully create \
	a ZFS filesystem with correct property set."

	typeset -i i=0
	while (( $i < ${#RW_FS_PROP[*]} )); do
	log_must zfs create -o ${RW_FS_PROP[$i]} $TESTPOOL/$TESTFS1
	datasetexists $TESTPOOL/$TESTFS1 \|\| \
	log_fail "zfs create $TESTPOOL/$TESTFS1 fail."
	propertycheck $TESTPOOL/$TESTFS1 ${RW_FS_PROP[i]} \|\| \
	log_fail "${RW_FS_PROP[i]} is failed to set."
	- log_must zfs destroy -f $TESTPOOL/$TESTFS1
	+ log_must_busy zfs destroy -f $TESTPOOL/$TESTFS1
	(( i = i + 1 ))
	done

	log_pass "'zfs create -o property=value filesystem' can successfully create \
	a ZFS filesystem with correct property set."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_create/zfs_create_005_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_create/zfs_create_005_pos.ksh
	index e953c65ded95..98cf70938e87 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_create/zfs_create_005_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_create/zfs_create_005_pos.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 2009 Sun Microsystems, Inc. All rights reserved.
	# Use is subject to license terms.
	#

	#
	# Copyright (c) 2016 by Delphix. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/cli_root/zfs_create/zfs_create_common.kshlib
	. $STF_SUITE/tests/functional/cli_root/zfs_create/properties.kshlib

	#
	# DESCRIPTION:
	# 'zfs create -o property=value filesystem' can successfully create a ZFS
	# filesystem with multiple properties set.
	#
	# STRATEGY:
	# 1. Create a ZFS filesystem in the storage pool with multiple -o options
	# 2. Verify the filesystem created successfully
	# 3. Verify the properties are correctly set
	#

	verify_runnable "both"

	function cleanup
	{
	datasetexists $TESTPOOL/$TESTFS1 && \
	- log_must zfs destroy -f $TESTPOOL/$TESTFS1
	+ destroy_dataset $TESTPOOL/$TESTFS1 -f
	}

	log_onexit cleanup


	log_assert "'zfs create -o property=value filesystem' can successfully create \
	a ZFS filesystem with multiple properties set."

	typeset -i i=0
	typeset opts=""

	while (( $i < ${#RW_FS_PROP[*]} )); do
	if [[ ${RW_FS_PROP[$i]} != "checksum" ]]; then
	opts="$opts -o ${RW_FS_PROP[$i]}"
	fi
	(( i = i + 1 ))
	done

	log_must zfs create $opts $TESTPOOL/$TESTFS1
	datasetexists $TESTPOOL/$TESTFS1 \|\| \
	log_fail "zfs create $TESTPOOL/$TESTFS1 fail."

	i=0
	while (( $i < ${#RW_FS_PROP[*]} )); do
	if [[ ${RW_FS_PROP[$i]} != "checksum" ]]; then
	propertycheck $TESTPOOL/$TESTFS1 ${RW_FS_PROP[i]} \|\| \
	log_fail "${RW_FS_PROP[i]} is failed to set."
	fi
	(( i = i + 1 ))
	done

	log_pass "'zfs create -o property=value filesystem' can successfully create \
	a ZFS filesystem with multiple properties set."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_create/zfs_create_006_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_create/zfs_create_006_pos.ksh
	index 2a664a424619..551ae78cd239 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_create/zfs_create_006_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_create/zfs_create_006_pos.ksh
	@@ -1,84 +1,84 @@
	#!/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) 2012, 2016 by Delphix. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/cli_root/zfs_create/zfs_create.cfg
	. $STF_SUITE/tests/functional/cli_root/zfs_create/zfs_create_common.kshlib
	. $STF_SUITE/tests/functional/cli_root/zfs_create/properties.kshlib

	#
	# DESCRIPTION:
	# 'zfs create -o property=value -V size volume' can successfully create a ZFS
	# volume with correct property set.
	#
	# STRATEGY:
	# 1. Create a ZFS volume in the storage pool with -o option
	# 2. Verify the volume created successfully
	# 3. Verify the property is correctly set
	#

	verify_runnable "global"

	function cleanup
	{
	datasetexists $TESTPOOL/$TESTVOL1 && \
	- log_must zfs destroy -f $TESTPOOL/$TESTVOL1
	+ destroy_dataset $TESTPOOL/$TESTVOL1 -f
	}

	log_onexit cleanup


	log_assert "'zfs create -o property=value -V size volume' can successfully \
	create a ZFS volume with correct property set."

	typeset -i i=0
	while (( $i < ${#RW_VOL_PROP[*]} )); do
	log_must zfs create -o ${RW_VOL_PROP[$i]} -V $VOLSIZE \
	$TESTPOOL/$TESTVOL1
	datasetexists $TESTPOOL/$TESTVOL1 \|\| \
	log_fail "zfs create -V size $TESTPOOL/$TESTVOL1 fail."
	propertycheck $TESTPOOL/$TESTVOL1 ${RW_VOL_PROP[i]} \|\| \
	log_fail "${RW_VOL_PROP[i]} is failed to set."
	log_must_busy zfs destroy -f $TESTPOOL/$TESTVOL1

	log_must zfs create -s -o ${RW_VOL_PROP[$i]} -V $VOLSIZE \
	$TESTPOOL/$TESTVOL1
	datasetexists $TESTPOOL/$TESTVOL1 \|\| \
	log_fail "zfs create -s -V $TESTPOOL/$TESTVOL1 fail."
	propertycheck $TESTPOOL/$TESTVOL1 ${RW_VOL_PROP[i]} \|\| \
	log_fail "${RW_VOL_PROP[i]} is failed to set."
	log_must_busy zfs destroy -f $TESTPOOL/$TESTVOL1

	(( i = i + 1 ))
	done

	log_pass "'zfs create -o property=value -V size volume' can successfully \
	create a ZFS volume with correct property set."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_create/zfs_create_008_neg.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_create/zfs_create_008_neg.ksh
	index 43c3ab0de338..a905e50dfaa2 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_create/zfs_create_008_neg.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_create/zfs_create_008_neg.ksh
	@@ -1,113 +1,112 @@
	#!/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) 2012, 2016 by Delphix. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/cli_root/zfs_create/zfs_create.cfg

	#
	# DESCRIPTION:
	# 'zfs create' should return an error with badly formed parameters.
	#
	# STRATEGY:
	# 1. Create an array of parameters
	# 2. For each parameter in the array, execute 'zfs create'
	# 3. Verify an error is returned.
	#

	verify_runnable "both"

	function cleanup
	{
	- if datasetexists $TESTPOOL/$TESTFS1 ; then
	- log_must zfs destroy -f $TESTPOOL/$TESTFS1
	- fi
	+ datasetexists $TESTPOOL/$TESTFS1 && \
	+ destroy_dataset $TESTPOOL/$TESTFS1 -f
	}

	log_onexit cleanup

	set -A args "ab" "-?" "-cV" "-Vc" "-c -V" "c" "V" "--c" "-e" "-s" \
	"-blah" "-cV 12k" "-s -cV 1P" "-sc" "-Vs 5g" "-o" "--o" "-O" "--O" \
	"-o QuOta=none" "-o quota=non" "-o quota=abcd" "-o quota=0" "-o quota=" \
	"-o ResErVaTi0n=none" "-o reserV=none" "-o reservation=abcd" "-o reserv=" \
	"-o recorDSize=64k" "-o recordsize=2048K" "-o recordsize=2M" \
	"-o recordsize=256" "-o recsize=" "-o recsize=zero" "-o recordsize=0" \
	"-o mountPoint=/tmp/tmpfile$$" "-o mountpoint=non0" "-o mountpoint=" \
	"-o mountpoint=LEGACY" "-o mounpoint=none" \
	"-o sharenfs=ON" "-o ShareNFS=off" "-o sharenfs=sss" \
	"-o checkSUM=on" "-o checksum=SHA256" "-o chsum=off" "-o checksum=aaa" \
	"-o checkSUM=on -V $VOLSIZE" "-o checksum=SHA256 -V $VOLSIZE" \
	"-o chsum=off -V $VOLSIZE" "-o checksum=aaa -V $VOLSIZE" \
	"-o compression=of" "-o ComPression=lzjb" "-o compress=ON" "-o compress=a" \
	"-o compression=of -V $VOLSIZE" "-o ComPression=lzjb -V $VOLSIZE" \
	"-o compress=ON -V $VOLSIZE" "-o compress=a -V $VOLSIZE" \
	"-o atime=ON" "-o ATime=off" "-o atime=bbb" \
	"-o deviCes=on" "-o devices=OFF" "-o devices=aaa" \
	"-o exec=ON" "-o EXec=off" "-o exec=aaa" \
	"-o readonly=ON" "-o reADOnly=off" "-o rdonly=OFF" "-o rdonly=aaa" \
	"-o readonly=ON -V $VOLSIZE" "-o reADOnly=off -V $VOLSIZE" \
	"-o rdonly=OFF -V $VOLSIZE" "-o rdonly=aaa -V $VOLSIZE" \
	"-o snapdIR=hidden" "-o snapdir=VISible" "-o snapdir=aaa" \
	"-o aclmode=DIScard" "-o aclmODE=groupmask" "-o aclmode=aaa" \
	"-o aclinherit=deny" "-o aclinHerit=secure" "-o aclinherit=aaa" \
	"-o type=volume" "-o type=snapshot" "-o type=filesystem" \
	"-o type=volume -V $VOLSIZE" "-o type=snapshot -V $VOLSIZE" \
	"-o type=filesystem -V $VOLSIZE" \
	"-o creation=aaa" "-o creation=aaa -V $VOLSIZE" \
	"-o used=10K" "-o used=10K -V $VOLSIZE" \
	"-o available=10K" "-o available=10K -V $VOLSIZE" \
	"-o referenced=10K" "-o referenced=10K -V $VOLSIZE" \
	"-o compressratio=1.00x" "-o compressratio=1.00x -V $VOLSIZE" \
	"-o version=0" "-o version=1.234" "-o version=10K" "-o version=-1" \
	"-o version=aaa" "-o version=999"
	if is_freebsd; then
	args+=("-o jailed=ON" "-o JaiLed=off" "-o jailed=aaa")
	else
	args+=("-o zoned=ON" "-o ZoNed=off" "-o zoned=aaa")
	fi

	log_assert "'zfs create' should return an error with badly-formed parameters."

	typeset -i i=0
	while [[ $i -lt ${#args[*]} ]]; do
	typeset arg=${args[i]}
	if is_freebsd; then
	# FreeBSD does not strictly validate share options (yet).
	if [[ "$arg" == "-o sharenfs="* ]]; then
	((i = i + 1))
	continue
	fi
	fi
	log_mustnot zfs create $arg $TESTPOOL/$TESTFS1
	log_mustnot zfs create -p $arg $TESTPOOL/$TESTFS1
	((i = i + 1))
	done

	log_pass "'zfs create' with badly formed parameters failed as expected."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_create/zfs_create_011_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_create/zfs_create_011_pos.ksh
	index 982a4ea16b5e..c5012d4f34a8 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_create/zfs_create_011_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_create/zfs_create_011_pos.ksh
	@@ -1,70 +1,69 @@
	#!/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.
	#

	. $STF_SUITE/include/libtest.shlib

	#
	# DESCRIPTION:
	# 'zfs create -p' should work as expected
	#
	# STRATEGY:
	# 1. To create $newdataset with -p option, first make sure the upper level
	# of $newdataset does not exist
	# 2. Make sure without -p option, 'zfs create' will fail
	# 3. Create $newdataset with -p option, verify it is created
	# 4. Run 'zfs create -p $newdataset' again, the exit code should be zero
	# even $newdataset exists
	#

	verify_runnable "both"

	function cleanup
	{
	- if datasetexists $TESTPOOL/$TESTFS1 ; then
	- log_must zfs destroy -rf $TESTPOOL/$TESTFS1
	- fi
	+ datasetexists $TESTPOOL/$TESTFS1 && \
	+ destroy_dataset $TESTPOOL/$TESTFS1 -rf
	}

	log_onexit cleanup

	typeset newdataset1="$TESTPOOL/$TESTFS1/$TESTFS/$TESTFS1"
	typeset newdataset2="$TESTPOOL/$TESTFS1/$TESTFS/$TESTVOL1"

	log_assert "'zfs create -p' works as expected."

	log_must verify_opt_p_ops "create" "fs" $newdataset1

	# verify volume creation
	if is_global_zone; then
	log_must verify_opt_p_ops "create" "vol" $newdataset2
	fi

	log_pass "'zfs create -p' works as expected."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_create/zfs_create_012_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_create/zfs_create_012_pos.ksh
	index d8aa06407755..a0b8d52f0c43 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_create/zfs_create_012_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_create/zfs_create_012_pos.ksh
	@@ -1,71 +1,70 @@
	#!/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.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/cli_root/zfs_upgrade/zfs_upgrade.kshlib

	#
	# DESCRIPTION:
	# 'zfs create -p -o version=1' should only cause the leaf filesystem to be version=1
	#
	# STRATEGY:
	# 1. Create $newdataset with -p option, verify it is created
	# 2. Verify only the leaf filesystem to be version=1, others use the current version
	#

	ZFS_VERSION=$(zfs upgrade \| head -1 \| awk '{print $NF}' \
	\| sed -e 's/\.//g')

	verify_runnable "both"

	function cleanup
	{
	- if datasetexists $TESTPOOL/$TESTFS1 ; then
	- log_must zfs destroy -rf $TESTPOOL/$TESTFS1
	- fi
	+ datasetexists $TESTPOOL/$TESTFS1 && \
	+ destroy_dataset $TESTPOOL/$TESTFS1 -rf
	}

	log_onexit cleanup


	typeset newdataset1="$TESTPOOL/$TESTFS1/$TESTFS/$TESTFS1"

	log_assert "'zfs create -p -o version=1' only cause the leaf filesystem to be version=1."

	log_must zfs create -p -o version=1 $newdataset1
	log_must datasetexists $newdataset1

	log_must check_fs_version $TESTPOOL/$TESTFS1/$TESTFS/$TESTFS1 1
	for fs in $TESTPOOL/$TESTFS1 $TESTPOOL/$TESTFS1/$TESTFS ; do
	log_must check_fs_version $fs $ZFS_VERSION
	done

	log_pass "'zfs create -p -o version=1' only cause the leaf filesystem to be version=1."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_create/zfs_create_014_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_create/zfs_create_014_pos.ksh
	index d1a8153d60e5..2482a68dc089 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_create/zfs_create_014_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_create/zfs_create_014_pos.ksh
	@@ -1,59 +1,58 @@
	#!/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.
	#
	. $STF_SUITE/include/libtest.shlib

	#
	# DESCRIPTION:
	# check 'zfs create <filesystem>' works at the name length boundary
	#
	# STRATEGY:
	# 1. Verify creating filesystem with name length 255 would succeed
	# 2. Verify creating filesystem with name length 256 would fail
	# 3. Verify the pool can be re-imported

	verify_runnable "both"

	# namelen 255 and 256
	TESTFS1=$(for i in $(seq $((254 - ${#TESTPOOL}))); do echo z ; done \| tr -d '\n')
	TESTFS2=$(for i in $(seq $((255 - ${#TESTPOOL}))); do echo z ; done \| tr -d '\n')

	function cleanup
	{
	- datasetexists $TESTPOOL/$TESTFS1 &&
	- log_must zfs destroy $TESTPOOL/$TESTFS1
	+ datasetexists $TESTPOOL/$TESTFS1 && destroy_dataset $TESTPOOL/$TESTFS1
	}

	log_onexit cleanup

	log_assert "'zfs create <filesystem>' can create a ZFS filesystem with name length 255."

	log_must zfs create $TESTPOOL/$TESTFS1
	log_mustnot zfs create $TESTPOOL/$TESTFS2
	log_must zpool export $TESTPOOL
	log_must zpool import $TESTPOOL

	log_pass "'zfs create <filesystem>' works as expected."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_create/zfs_create_crypt_combos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_create/zfs_create_crypt_combos.ksh
	index 141b2557d622..758b800c2fe8 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_create/zfs_create_crypt_combos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_create/zfs_create_crypt_combos.ksh
	@@ -1,99 +1,99 @@
	#!/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) 2017, Datto, Inc. All rights reserved.
	# Copyright (c) 2019, DilOS
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/cli_root/zfs_create/zfs_create_common.kshlib
	. $STF_SUITE/tests/functional/cli_root/zfs_create/properties.kshlib

	#
	# DESCRIPTION:
	# 'zfs create' should create an encrypted dataset with a valid encryption
	# algorithm, key format, key location, and key.
	#
	# STRATEGY:
	# 1. Create a filesystem for each combination of encryption type and key format
	# 2. Verify that each filesystem has the correct properties set
	#

	verify_runnable "both"

	function cleanup
	{
	datasetexists $TESTPOOL/$TESTFS1 && \
	- log_must zfs destroy -f $TESTPOOL/$TESTFS1
	+ destroy_dataset $TESTPOOL/$TESTFS1 -f
	}

	log_onexit cleanup

	set -A ENCRYPTION_ALGS \
	"encryption=on" \
	"encryption=aes-128-ccm" \
	"encryption=aes-192-ccm" \
	"encryption=aes-256-ccm" \
	"encryption=aes-128-gcm" \
	"encryption=aes-192-gcm" \
	"encryption=aes-256-gcm"

	set -A ENCRYPTION_PROPS \
	"encryption=aes-256-gcm" \
	"encryption=aes-128-ccm" \
	"encryption=aes-192-ccm" \
	"encryption=aes-256-ccm" \
	"encryption=aes-128-gcm" \
	"encryption=aes-192-gcm" \
	"encryption=aes-256-gcm"

	set -A KEYFORMATS "keyformat=raw" \
	"keyformat=hex" \
	"keyformat=passphrase"

	set -A USER_KEYS "zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz" \
	"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb" \
	"abcdefgh"

	log_assert "'zfs create' should create encrypted datasets using all" \
	"combinations of supported properties"

	typeset -i i=0
	while (( i < ${#ENCRYPTION_ALGS[*]} )); do
	typeset -i j=0
	while (( j < ${#KEYFORMATS[*]} )); do
	log_must eval "printf '%s' ${USER_KEYS[j]} \| zfs create" \
	"-o ${ENCRYPTION_ALGS[i]} -o ${KEYFORMATS[j]}" \
	"$TESTPOOL/$TESTFS1"

	datasetexists $TESTPOOL/$TESTFS1 \|\| \
	log_fail "Failed to create dataset using" \
	"${ENCRYPTION_ALGS[i]} and ${KEYFORMATS[j]}"

	propertycheck $TESTPOOL/$TESTFS1 ${ENCRYPTION_PROPS[i]} \|\| \
	log_fail "failed to set ${ENCRYPTION_ALGS[i]}"
	propertycheck $TESTPOOL/$TESTFS1 ${KEYFORMATS[j]} \|\| \
	log_fail "failed to set ${KEYFORMATS[j]}"

	- log_must zfs destroy -f $TESTPOOL/$TESTFS1
	+ log_must_busy zfs destroy -f $TESTPOOL/$TESTFS1
	(( j = j + 1 ))
	done
	(( i = i + 1 ))
	done

	log_pass "'zfs create' creates encrypted datasets using all combinations of" \
	"supported properties"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_create/zfs_create_dryrun.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_create/zfs_create_dryrun.ksh
	index 64b8296f46bf..703ae8043d48 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_create/zfs_create_dryrun.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_create/zfs_create_dryrun.ksh
	@@ -1,169 +1,168 @@
	#!/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 2019 Joyent, Inc.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/cli_root/zfs_create/zfs_create_common.kshlib

	#
	# DESCRIPTION:
	# zfs create -n should perform basic sanity checking but should never create a
	# dataset. If -v and/or -P are used, it should verbose about what would be
	# created if sanity checks pass.
	#
	# STRATEGY:
	# 1. Attempt to create a file system and a volume using various combinations of
	# -n with -v and -P.
	#

	verify_runnable "both"

	#
	# Verifies that valid commands with -n and without -[vP]:
	# - succeed
	# - do not create a dataset
	# - do not generate output
	#
	function dry_create_no_output
	{
	typeset -a cmd=(zfs create -n "$@")

	log_note "$0: ${cmd[@]}"
	log_must "${cmd[@]}"
	datasetexists "$TESTPOOL/$TESTFS1" &&
	log_fail "$TESTPOOL/$TESTFS1 unexpectedly created by '${cmd[@]}'"
	typeset out=$("${cmd[@]}" 2>&1)
	[[ -z "$out" ]] \|\|
	log_fail "unexpected output '$out' from '${cmd[@]}'"
	}

	#
	# Verifies that commands with invalid properties or invalid property values
	# - fail
	# - do not create a dataset
	# - generate a message on stderr
	#
	function dry_create_error
	{
	typeset -a cmd=(zfs create -n "$@")

	log_note "$0: ${cmd[@]}"
	log_mustnot "${cmd[@]}"
	datasetexists "$TESTPOOL/$TESTFS1" &&
	log_fail "$TESTPOOL/$TESTFS1 unexpectedly created by '${cmd[@]}'"
	typeset out=$("${cmd[@]}" 2>&1 >/dev/null)
	[[ -z "$out" ]] &&
	log_fail "expected an error message but got none from '${cmd[@]}'"
	}

	#
	# Verifies that dry-run commands with parseable output
	# - succeed
	# - do not create datasets
	# - generate parseable output on stdout
	# - output matches expectations
	#
	function dry_create_parseable
	{
	typeset -n exp=$1
	shift
	typeset -a cmd=(zfs create -Pn "$@")
	typeset ds=${cmd[${#cmd[@]} - 1]}
	typeset out
	typeset -a toks
	typeset -a props
	typeset found_create=false

	log_note "$0: ${cmd[@]}"
	out=$("${cmd[@]}")
	(( $? == 0 )) \|\|
	log_fail "unexpected failure getting stdout from '${cmd[@]}'"
	datasetexists "$TESTPOOL/$TESTFS1" &&
	log_fail "$TESTPOOL/$TESTFS1 unexpectedly created by '${cmd[@]}'"
	echo "$out" \| while IFS=$'\t' read -A toks; do
	log_note "verifying ${toks[@]}"
	case ${toks[0]} in
	create)
	log_must test "${#toks[@]}" -eq 2
	log_must test "${toks[1]}" == "$ds"
	found_create="yes, I found create"
	;;
	property)
	log_must test "${#toks[@]}" -eq 3
	typeset prop=${toks[1]}
	typeset val=${toks[2]}
	if [[ -z "${exp[$prop]}" ]]; then
	log_fail "unexpectedly got property '$prop'"
	fi
	# We may not know the exact value a property will take
	# on. This is the case for at least refreservation.
	if [[ ${exp[$prop]} != "*" ]]; then
	log_must test "${exp[$prop]}" == "$val"
	fi
	unset exp[$prop]
	;;
	*)
	log_fail "Unexpected line ${toks[@]}"
	;;
	esac
	done

	log_must test "$found_create" == "yes, I found create"
	log_must test "extra props: ${!exp[@]}" == "extra props: "
	}

	function cleanup
	{
	- if datasetexists "$TESTPOOL/$TESTFS1"; then
	- log_must zfs destroy -r "$TESTPOOL/$TESTFS1"
	- fi
	+ datasetexists "$TESTPOOL/$TESTFS1" && \
	+ destroy_dataset "$TESTPOOL/$TESTFS1" -r
	}
	log_onexit cleanup

	log_assert "zfs create -n creates nothing but can describe what would be" \
	"created"

	# Typical creations should succeed
	dry_create_no_output "$TESTPOOL/$TESTFS1"
	dry_create_no_output -V 10m "$TESTPOOL/$TESTFS1"
	# It shouldn't do a space check right now
	dry_create_no_output -V 100t "$TESTPOOL/$TESTFS1"
	# It shouldn't create parent datasets either
	dry_create_no_output -p "$TESTPOOL/$TESTFS1/$TESTFS2"
	dry_create_no_output -pV 10m "$TESTPOOL/$TESTFS1/$TESTFS2"

	# Various invalid properties should be recognized and result in an error
	dry_create_error -o nosuchprop=42 "$TESTPOOL/$TESTFS1"
	dry_create_error -b 1234 -V 10m "$TESTPOOL/$TESTFS1"

	# Parseable output should be parseable.
	typeset -A expect
	expect=([compression]=on)
	dry_create_parseable expect -o compression=on "$TESTPOOL/$TESTFS1"

	# Sparse volumes should not get a gratuitous refreservation
	expect=([volblocksize]=4096 [volsize]=$((1024 * 1024 * 10)))
	dry_create_parseable expect -b 4k -V 10m -s "$TESTPOOL/$TESTFS1"

	# Non-sparse volumes should have refreservation
	expect=(
	[volblocksize]=4096
	[volsize]=$((1024 * 1024 * 10))
	[refreservation]="*"
	)
	dry_create_parseable expect -b 4k -V 10m "$TESTPOOL/$TESTFS1"

	log_pass "zfs create -n creates nothing but can describe what would be" \
	"created"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_create/zfs_create_encrypted.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_create/zfs_create_encrypted.ksh
	index 7e5072f0d5fd..e32545c689fe 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_create/zfs_create_encrypted.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_create/zfs_create_encrypted.ksh
	@@ -1,136 +1,136 @@
	#!/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) 2017, Datto, Inc. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/cli_root/zfs_create/zfs_create_common.kshlib
	. $STF_SUITE/tests/functional/cli_root/zfs_create/properties.kshlib
	. $STF_SUITE/tests/functional/cli_root/zfs_load-key/zfs_load-key_common.kshlib

	#
	# DESCRIPTION:
	# ZFS should create datasets only if they have a valid combination of
	# encryption properties set.
	#
	# penc = parent encrypted
	# enc = encryption
	# loc = keylocation provided
	# fmt = keyformat provided
	#
	# penc enc fmt loc valid notes
	# -------------------------------------------
	# no unspec 0 0 yes inherit no encryption (not tested here)
	# no unspec 0 1 no no crypt specified
	# no unspec 1 0 no no crypt specified
	# no unspec 1 1 no no crypt specified
	# no off 0 0 yes explicit no encryption
	# no off 0 1 no keylocation given, but crypt off
	# no off 1 0 no keyformat given, but crypt off
	# no off 1 1 no keyformat given, but crypt off
	# no on 0 0 no no keyformat specified for new key
	# no on 0 1 no no keyformat specified for new key
	# no on 1 0 yes new encryption root
	# no on 1 1 yes new encryption root
	# yes unspec 0 0 yes inherit encryption
	# yes unspec 0 1 no no keyformat specified
	# yes unspec 1 0 yes new encryption root, crypt inherited
	# yes unspec 1 1 yes new encryption root, crypt inherited
	# yes off 0 0 yes unencrypted child of encrypted parent
	# yes off 0 1 no keylocation given, but crypt off
	# yes off 1 0 no keyformat given, but crypt off
	# yes off 1 1 no keyformat given, but crypt off
	# yes on 0 0 yes inherited encryption, local crypt
	# yes on 0 1 no no keyformat specified for new key
	# yes on 1 0 yes new encryption root
	# yes on 1 1 yes new encryption root
	#
	# STRATEGY:
	# 1. Attempt to create a dataset using all combinations of encryption
	# properties
	#

	verify_runnable "both"

	function cleanup
	{
	datasetexists $TESTPOOL/$TESTFS1 && \
	- log_must zfs destroy -r $TESTPOOL/$TESTFS1
	+ destroy_dataset $TESTPOOL/$TESTFS1 -r
	datasetexists $TESTPOOL/$TESTFS2 && \
	- log_must zfs destroy -r $TESTPOOL/$TESTFS2
	+ destroy_dataset $TESTPOOL/$TESTFS2 -r
	}
	log_onexit cleanup

	log_assert "ZFS should create datasets only if they have a valid" \
	"combination of encryption properties set."

	# Unencrypted parent
	log_must zfs create $TESTPOOL/$TESTFS1
	log_mustnot zfs create -o keyformat=passphrase $TESTPOOL/$TESTFS1/c1
	log_mustnot zfs create -o keylocation=prompt $TESTPOOL/$TESTFS1/c1
	log_mustnot zfs create -o keyformat=passphrase -o keylocation=prompt \
	$TESTPOOL/$TESTFS1/c1

	log_must zfs create -o encryption=off $TESTPOOL/$TESTFS1/c1
	log_mustnot zfs create -o encryption=off -o keylocation=prompt \
	$TESTPOOL/$TESTFS1/c2
	log_mustnot zfs create -o encryption=off -o keyformat=passphrase \
	$TESTPOOL/$TESTFS1/c2
	log_mustnot zfs create -o encryption=off -o keyformat=passphrase \
	-o keylocation=prompt $TESTPOOL/$TESTFS1/c2

	log_mustnot zfs create -o encryption=on $TESTPOOL/$TESTFS1/c2
	log_mustnot zfs create -o encryption=on -o keylocation=prompt \
	$TESTPOOL/$TESTFS1/c2
	log_must eval "echo $PASSPHRASE \| zfs create -o encryption=on" \
	"-o keyformat=passphrase $TESTPOOL/$TESTFS1/c3"
	log_must eval "echo $PASSPHRASE \| zfs create -o encryption=on" \
	"-o keyformat=passphrase -o keylocation=prompt $TESTPOOL/$TESTFS1/c4"

	# Encrypted parent
	log_must eval "echo $PASSPHRASE \| zfs create -o encryption=on" \
	"-o keyformat=passphrase $TESTPOOL/$TESTFS2"

	log_must zfs create $TESTPOOL/$TESTFS2/c1
	log_mustnot zfs create -o keylocation=prompt $TESTPOOL/$TESTFS2/c2
	log_must eval "echo $PASSPHRASE \| zfs create -o keyformat=passphrase" \
	"$TESTPOOL/$TESTFS2/c3"
	log_must eval "echo $PASSPHRASE \| zfs create -o keyformat=passphrase" \
	"-o keylocation=prompt $TESTPOOL/$TESTFS2/c4"

	log_must zfs create -o encryption=off $TESTPOOL/$TESTFS2/c5
	log_must test "$(get_prop 'encryption' $TESTPOOL/$TESTFS2/c5)" == "off"

	log_mustnot zfs create -o encryption=off -o keylocation=prompt \
	$TESTPOOL/$TESTFS2/c5
	log_mustnot zfs create -o encryption=off -o keyformat=passphrase \
	$TESTPOOL/$TESTFS2/c5
	log_mustnot zfs create -o encryption=off -o keyformat=passphrase \
	-o keylocation=prompt $TESTPOOL/$TESTFS2/c5

	log_must eval "echo $PASSPHRASE \| zfs create -o encryption=on" \
	"$TESTPOOL/$TESTFS2/c6"
	log_mustnot zfs create -o encryption=on -o keylocation=prompt \
	$TESTPOOL/$TESTFS2/c7
	log_must eval "echo $PASSPHRASE \| zfs create -o encryption=on" \
	"-o keyformat=passphrase $TESTPOOL/$TESTFS2/c7"
	log_must eval "echo $PASSPHRASE \| zfs create -o encryption=on" \
	"-o keyformat=passphrase -o keylocation=prompt $TESTPOOL/$TESTFS2/c8"

	log_pass "ZFS creates datasets only if they have a valid combination of" \
	"encryption properties set."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_create/zfs_create_verbose.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_create/zfs_create_verbose.ksh
	index a07ccc7e9ace..acab500062ca 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_create/zfs_create_verbose.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_create/zfs_create_verbose.ksh
	@@ -1,165 +1,164 @@
	#!/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 2019 Joyent, Inc.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/cli_root/zfs_create/zfs_create_common.kshlib

	#
	# DESCRIPTION:
	# zfs create -P without -n should be verbose about dataset creation.
	#
	# STRATEGY:
	# 1. Attempt to create a file system and a volume using various properties
	# and -P
	# 2. Exercise the combination of -p and -P.
	#

	verify_runnable "both"

	#
	# Verifies that non dry-run commands with parseable output
	# - succeed
	# - create datasets
	# - generate parseable output on stdout
	# - output matches expectations
	#
	function dry_create_parseable
	{
	typeset -n exp=$1
	shift
	typeset -a cmd=(zfs create -P "$@")
	typeset ds=${cmd[${#cmd[@]} - 1]}
	typeset out
	typeset -a toks
	typeset -a props
	typeset found_create=false
	typeset create_ancestors=
	typeset opt

	# Parse the arguments to see if -p was used.
	while getopts :PV:b:ospv opt; do
	case $opt in
	p) create_ancestors=needed ;;
	*) continue ;;
	esac
	done

	log_note "$0: ${cmd[@]}"
	out=$("${cmd[@]}")
	(( $? == 0 )) \|\|
	log_fail "unexpected failure getting stdout from '${cmd[@]}'"
	datasetexists "$TESTPOOL/$TESTFS1" \|\|
	log_fail "$TESTPOOL/$TESTFS1 unexpectedly created by '${cmd[@]}'"
	echo "$out" \| while IFS=$'\t' read -A toks; do
	log_note "verifying ${toks[@]}"
	case ${toks[0]} in
	create_ancestors)
	case "$create_ancestors" in
	needed)
	log_must test "${toks[1]}" == "$ds"
	create_ancestors="found ${toks[1]}"
	;;
	found*)
	log_fail "multiple ancestor creation" \
	"$create_ancestors and ${toks[1]}"
	;;
	"")
	log_fail "unexpected create_ancestors"
	;;
	*)
	log_fail "impossible error: fix the test"
	;;
	esac
	;;
	create)
	log_must test "${#toks[@]}" -eq 2
	log_must test "${toks[1]}" == "$ds"
	found_create="yes, I found create"
	;;
	property)
	log_must test "${#toks[@]}" -eq 3
	typeset prop=${toks[1]}
	typeset val=${toks[2]}
	if [[ -z "${exp[$prop]}" ]]; then
	log_fail "unexpectedly got property '$prop'"
	fi
	# We may not know the exact value a property will take
	# on. This is the case for at least refreservation.
	if [[ ${exp[$prop]} != "*" ]]; then
	log_must test "${exp[$prop]}" == "$val"
	fi
	unset exp[$prop]
	;;
	*)
	log_fail "Unexpected line ${toks[@]}"
	;;
	esac
	done

	log_must test "$found_create" == "yes, I found create"
	log_must test "extra props: ${!exp[@]}" == "extra props: "

	case "$create_ancestors" in
	"")
	log_must_busy zfs destroy "$ds"
	;;
	"found $ds")
	log_must_busy zfs destroy -r "$(echo "$ds" \| cut -d/ -f1-2)"
	;;
	needed)
	log_fail "Expected but did not find create_ancestors"
	;;
	*)
	log_fail "Unexpected value for create_ancestors:" \
	"$create_ancestors"
	;;
	esac
	}

	function cleanup
	{
	- if datasetexists "$TESTPOOL/$TESTFS1"; then
	- log_must_busy zfs destroy -r "$TESTPOOL/$TESTFS1"
	- fi
	+ datasetexists "$TESTPOOL/$TESTFS1" && \
	+ destroy_dataset "$TESTPOOL/$TESTFS1" -r
	}
	log_onexit cleanup

	log_assert "zfs create -v creates datasets verbosely"

	# Parseable output should be parseable.
	typeset -A expect
	expect=([compression]=on)
	dry_create_parseable expect -o compression=on "$TESTPOOL/$TESTFS1"

	# Ancestor creation with -p should emit relevant line
	expect=([compression]=on)
	dry_create_parseable expect -p -o compression=on "$TESTPOOL/$TESTFS1"
	expect=([compression]=on)
	dry_create_parseable expect -p -o compression=on "$TESTPOOL/$TESTFS1/$TESTVOL"

	# Sparse volumes should not get a gratuitous refreservation
	expect=([volblocksize]=4096 [volsize]=$((1024 * 1024 * 10)))
	dry_create_parseable expect -b 4k -V 10m -s "$TESTPOOL/$TESTFS1"

	# Non-sparse volumes should have refreservation
	expect=(
	[volblocksize]=4096
	[volsize]=$((1024 * 1024 * 10))
	[refreservation]="*"
	)
	dry_create_parseable expect -b 4k -V 10m "$TESTPOOL/$TESTFS1"

	log_pass "zfs create -v creates datasets verbosely"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_destroy/zfs_destroy_001_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_destroy/zfs_destroy_001_pos.ksh
	index 26857d48d48b..11157e93c78d 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_destroy/zfs_destroy_001_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_destroy/zfs_destroy_001_pos.ksh
	@@ -1,235 +1,233 @@
	#!/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) 2012, 2016 by Delphix. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/cli_root/zfs_destroy/zfs_destroy.cfg
	. $STF_SUITE/tests/functional/cli_root/zfs_destroy/zfs_destroy_common.kshlib

	#
	# DESCRIPTION:
	# 'zfs destroy -r\|-rf\|-R\|-Rf <fs\|ctr\|vol\|snap>' should recursively destroy
	# all children and clones based on options.
	#
	# STRATEGY:
	# 1. Create test environment according to options. There are three test
	# models can be created. Only ctr, fs & vol; with snap; with clone.
	# 2. According to option, make the dataset busy or not.
	# 3. Run 'zfs destroy [-rRf] <dataset>'
	# 4. According to dataset and option, check if get the expected results.
	#

	verify_runnable "both"

	#
	# According to parameters, 1st, create suitable testing environment. 2nd,
	# run 'zfs destroy $opt <dataset>'. 3rd, check the system status.
	#
	# $1 option of 'zfs destroy'
	# $2 dataset will be destroyed.
	#
	function test_n_check
	{
	typeset opt=$1
	typeset dtst=$2

	if ! is_global_zone ; then
	if [[ $dtst == $VOL \|\| $dtst == $VOLSNAP ]]; then
	log_note "UNSUPPORTED: Volume are unavailable in LZ."
	return
	fi
	fi

	# '-f' has no effect on non-filesystems
	if [[ $opt == -f ]]; then
	if [[ $dtst != $FS ]]; then
	log_note "UNSUPPORTED: '-f ' is only available for " \
	"leaf FS."
	return
	fi
	fi

	# Clean the test environment and make it clear.
	- if datasetexists $CTR; then
	- log_must zfs destroy -Rf $CTR
	- fi
	+ datasetexists $CTR && destroy_dataset $CTR -Rf

	# According to option create test compatible environment.
	case $opt in
	-r\|-rf) setup_testenv snap ;;
	-R\|-Rf) setup_testenv clone ;;
	-f) setup_testenv ;;
	*) log_fail "Incorrect option: '$opt'." ;;
	esac

	#
	# According to different dataset type, create busy condition when try to
	# destroy this dataset.
	#
	typeset mpt_dir
	case $dtst in
	$CTR\|$FS)
	if [[ $opt == f ]]; then
	mpt_dir=$(get_prop mountpoint $FS)
	pidlist="$pidlist $(mkbusy \
	$mpt_dir/$TESTFILE0)"
	log_note "mkbusy $mpt_dir/$TESTFILE0 " \
	"(pidlist: $pidlist)"
	[[ -z $pidlist ]] && \
	log_fail "Failure from mkbusy"
	log_mustnot zfs destroy -rR $dtst
	fi
	;;
	$VOL)
	if [[ $opt == f ]]; then
	pidlist="$pidlist $(mkbusy \
	$TESTDIR1/$TESTFILE0)"
	log_note "mkbusy $TESTDIR1/$TESTFILE0 " \
	"(pidlist: $pidlist)"
	[[ -z $pidlist ]] && \
	log_fail "Failure from mkbusy"
	log_mustnot zfs destroy -rR $dtst
	fi
	;;
	$VOLSNAP)
	if [[ $opt == f ]]; then
	pidlist="$pidlist $(mkbusy \
	$TESTDIR1/$TESTFILE0)"
	log_note "mkbusy $TESTDIR1/$TESTFILE0 " \
	"(pidlist: $pidlist)"
	[[ -z $pidlist ]] && \
	log_fail "Failure from mkbusy"
	log_must_busy zfs destroy -rR $dtst
	log_must zfs snapshot $dtst
	fi
	;;
	$FSSNAP)
	if [[ $opt == f ]]; then
	mpt_dir=$(snapshot_mountpoint $dtst)
	pidlist="$pidlist $(mkbusy $mpt_dir)"
	log_note "mkbusy $mpt_dir (pidlist: $pidlist)"
	[[ -z $pidlist ]] && \
	log_fail "Failure from mkbusy"
	if is_linux ; then
	log_mustnot zfs destroy -rR $dtst
	else
	log_must zfs destroy -rR $dtst
	log_must zfs snapshot $dtst
	fi
	fi
	;;
	*) log_fail "Unsupported dataset: '$dtst'."
	esac

	# Kill any lingering instances of mkbusy, and clear the list.
	if is_linux ; then
	[[ -z $pidlist ]] \|\| log_must kill -TERM $pidlist
	pidlist=""
	log_mustnot pgrep -fl mkbusy
	fi

	# Firstly, umount ufs filesystem which was created by zfs volume.
	if is_global_zone; then
	log_must umount -f $TESTDIR1
	fi

	# Invoke 'zfs destroy [-rRf] <dataset>'
	log_must_busy zfs destroy $opt $dtst
	block_device_wait

	# Kill any lingering instances of mkbusy, and clear the list.
	if ! is_linux ; then
	[[ -z $pidlist ]] \|\| log_must kill -TERM $pidlist
	pidlist=""
	log_mustnot pgrep -fl mkbusy
	fi

	case $dtst in
	$CTR) check_dataset datasetnonexists \
	$CTR $FS $VOL $FSSNAP $VOLSNAP
	if [[ $opt == R ]]; then
	check_dataset datasetnonexists \
	$FSCLONE $VOLCLONE
	fi
	;;
	$FS) check_dataset datasetexists $CTR $VOL
	check_dataset datasetnonexists $FS
	if [[ $opt != -f ]]; then
	check_dataset datasetexists $VOLSNAP
	check_dataset datasetnonexists $FSSNAP
	fi
	if [[ $opt == R ]]; then
	check_dataset datasetexists $VOLCLONE
	check_dataset datasetnonexists $FSCLONE
	fi
	;;
	$VOL) check_dataset datasetexists $CTR $FS $FSSNAP
	check_dataset datasetnonexists $VOL $VOLSNAP
	if [[ $opt == R ]]; then
	check_dataset datasetexists $FSCLONE
	check_dataset datasetnonexists $VOLCLONE
	fi
	;;
	$FSSNAP)
	check_dataset datasetexists $CTR $FS $VOL $VOLSNAP
	check_dataset datasetnonexists $FSSNAP
	if [[ $opt == R ]]; then
	check_dataset datasetexists $VOLCLONE
	check_dataset datasetnonexists $FSCLONE
	fi
	;;
	$VOLSNAP)
	check_dataset datasetexists $CTR $FS $VOL $FSSNAP
	check_dataset datasetnonexists $VOLSNAP
	if [[ $opt == R ]]; then
	check_dataset datasetexists $FSCLONE
	check_dataset datasetnonexists $VOLCLONE
	fi
	;;
	esac

	log_note "'zfs destroy $opt $dtst' passed."
	}

	log_assert "'zfs destroy -r\|-R\|-f\|-rf\|-Rf <fs\|ctr\|vol\|snap>' should " \
	"recursively destroy all children."
	log_onexit cleanup_testenv

	typeset dtst=""
	typeset opt=""
	typeset pidlist=""
	for dtst in $CTR $FS $VOL $FSSNAP $VOLSNAP; do
	for opt in "-r" "-R" "-f" "-rf" "-Rf"; do
	log_note "Starting test: zfs destroy $opt $dtst"
	test_n_check $opt $dtst
	done
	done

	log_pass "'zfs destroy -r\|-R\|-f\|-rf\|-Rf <fs\|ctr\|vol\|snap>' passed."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_destroy/zfs_destroy_003_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_destroy/zfs_destroy_003_pos.ksh
	index 04e9713124b1..8b7e59b412b4 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_destroy/zfs_destroy_003_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_destroy/zfs_destroy_003_pos.ksh
	@@ -1,156 +1,155 @@
	#!/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) 2012, 2016 by Delphix. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/cli_root/zfs_destroy/zfs_destroy.cfg

	#
	# DESCRIPTION:
	# Verify 'zfs destroy [-rR]' succeeds as root.
	#
	# STRATEGY:
	# 1. Create two datasets in the storage pool
	# 2. Create fs,vol,ctr,snapshot and clones of snapshot in the two datasets
	# 3. Create clone in the second dataset for the snapshot in the first dataset
	# 4. Verify 'zfs destroy -r' fails to destroy dataset with clone outside it
	# 5. Verify 'zfs destroy -R' succeeds to destroy dataset with clone outside it
	# 6. Verify 'zfs destroy -r' succeeds to destroy dataset without clone outside it.
	#

	verify_runnable "both"

	function cleanup
	{
	for obj in $ctr2 $ctr1 $ctr; do
	- datasetexists $obj && \
	- log_must zfs destroy -Rf $obj
	+ datasetexists $obj && destroy_dataset $obj -Rf
	done

	for mntp in $TESTDIR1 $TESTDIR2; do
	[[ -d $mntp ]] && \
	log_must rm -rf $mntp
	done
	}

	log_assert "Verify that 'zfs destroy [-rR]' succeeds as root. "

	log_onexit cleanup

	#
	# Preparations for testing
	#
	for dir in $TESTDIR1 $TESTDIR2; do
	[[ ! -d $dir ]] && \
	log_must mkdir -p $dir
	done

	ctr=$TESTPOOL/$TESTCTR
	ctr1=$TESTPOOL/$TESTCTR1
	ctr2=$ctr/$TESTCTR2
	ctr3=$ctr1/$TESTCTR2
	child_fs=$ctr/$TESTFS1
	child_fs1=$ctr1/$TESTFS2
	child_fs_mntp=$TESTDIR1
	child_fs1_mntp=$TESTDIR2
	child_vol=$ctr/$TESTVOL
	child_vol1=$ctr1/$TESTVOL
	child_fs_snap=$child_fs@snap
	child_fs1_snap=$child_fs1@snap
	child_fs_snap_clone=$ctr/$TESTCLONE
	child_fs_snap_clone1=$ctr1/${TESTCLONE}_across_ctr
	child_fs_snap_clone2=$ctr2/$TESTCLONE2
	child_fs1_snap_clone=$ctr1/$TESTCLONE1
	child_fs1_snap_clone1=$ctr/${TESTCLONE1}_across_ctr

	#
	# Create two datasets in the storage pool
	#
	log_must zfs create $ctr
	log_must zfs create $ctr1

	#
	# Create children datasets fs,vol,snapshot in the datasets, and
	# clones across two datasets
	#
	log_must zfs create $ctr2

	for fs in $child_fs $child_fs1; do
	log_must zfs create $fs
	done

	log_must zfs set mountpoint=$child_fs_mntp $child_fs
	log_must zfs set mountpoint=$child_fs1_mntp $child_fs1

	for snap in $child_fs_snap $child_fs1_snap; do
	log_must zfs snapshot $snap
	done

	if is_global_zone ; then
	for vol in $child_vol $child_vol1; do
	log_must zfs create -V $VOLSIZE $vol
	done
	fi

	for clone in $child_fs_snap_clone $child_fs_snap_clone1; do
	log_must zfs clone $child_fs_snap $clone
	done


	for clone in $child_fs1_snap_clone $child_fs1_snap_clone1; do
	log_must zfs clone $child_fs1_snap $clone
	done

	log_note "Verify that 'zfs destroy -r' fails to destroy dataset " \
	"with dependent clone outside it."

	for obj in $child_fs $child_fs1 $ctr $ctr1; do
	log_mustnot zfs destroy -r $obj
	datasetexists $obj \|\| \
	log_fail "'zfs destroy -r' fails to keep dependent " \
	"clone outside the hierarchy."
	done


	log_note "Verify that 'zfs destroy -R' succeeds to destroy dataset " \
	"with dependent clone outside it."

	-log_must zfs destroy -R $ctr1
	+log_must_busy zfs destroy -R $ctr1
	datasetexists $ctr1 && \
	log_fail "'zfs destroy -R' fails to destroy dataset with clone outside it."

	log_note "Verify that 'zfs destroy -r' succeeds to destroy dataset " \
	"without dependent clone outside it."

	-log_must zfs destroy -r $ctr
	+log_must_busy zfs destroy -r $ctr
	datasetexists $ctr && \
	log_fail "'zfs destroy -r' fails to destroy dataset with clone outside it."

	log_pass "'zfs destroy [-rR] succeeds as root."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_destroy/zfs_destroy_004_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_destroy/zfs_destroy_004_pos.ksh
	index 3db1331ff57e..9a2ff6bea36d 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_destroy/zfs_destroy_004_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_destroy/zfs_destroy_004_pos.ksh
	@@ -1,126 +1,122 @@
	#!/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) 2012, 2016 by Delphix. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/cli_root/zfs_destroy/zfs_destroy.cfg

	#
	# DESCRIPTION:
	# Verify 'zfs destroy -f' succeeds as root.
	#
	# STRATEGY:
	# 1. Create filesystem in the storage pool
	# 2. Set mountpoint for the filesystem and make it busy
	# 3. Verify that 'zfs destroy' fails to destroy the filesystem
	# 4. Verify 'zfs destroy -f' succeeds to destroy the filesystem.
	#

	verify_runnable "both"

	function cleanup
	{
	cd $olddir

	- datasetexists $clone && \
	- log_must zfs destroy -f $clone
	-
	- snapexists $snap && \
	- log_must zfs destroy -f $snap
	+ datasetexists $clone && destroy_dataset $clone -f
	+ snapexists $snap && destroy_dataset $snap -f

	for fs in $fs1 $fs2; do
	- datasetexists $fs && \
	- log_must zfs destroy -f $fs
	+ datasetexists $fs && destroy_dataset $fs -f
	done

	for dir in $TESTDIR1 $TESTDIR2; do
	[[ -d $dir ]] && \
	log_must rm -rf $dir
	done
	}

	log_assert "Verify that 'zfs destroy -f' succeeds as root. "

	log_onexit cleanup

	#
	# Preparations for testing
	#
	olddir=$PWD

	for dir in $TESTDIR1 $TESTDIR2; do
	[[ ! -d $dir ]] && \
	log_must mkdir -p $dir
	done

	fs1=$TESTPOOL/$TESTFS1
	mntp1=$TESTDIR1
	fs2=$TESTPOOL/$TESTFS2
	snap=$TESTPOOL/$TESTFS2@snap
	clone=$TESTPOOL/$TESTCLONE
	mntp2=$TESTDIR2

	#
	# Create filesystem and clone in the storage pool, mount them and
	# make the mountpoint busy
	#
	for fs in $fs1 $fs2; do
	log_must zfs create $fs
	done

	log_must zfs snapshot $snap
	log_must zfs clone $snap $clone

	log_must zfs set mountpoint=$mntp1 $fs1
	log_must zfs set mountpoint=$mntp2 $clone

	for arg in "$fs1 $mntp1" "$clone $mntp2"; do
	fs=`echo $arg \| awk '{print $1}'`
	mntp=`echo $arg \| awk '{print $2}'`

	log_note "Verify that 'zfs destroy' fails to" \
	"destroy filesystem when it is busy."
	cd $mntp
	log_mustnot zfs destroy $fs

	if is_linux; then
	log_mustnot zfs destroy -f $fs
	datasetnonexists $fs && \
	log_fail "'zfs destroy -f' destroyed busy filesystem."
	else
	log_must zfs destroy -f $fs
	datasetexists $fs && \
	log_fail "'zfs destroy -f' fail to destroy busy filesystem."
	fi

	cd $olddir
	done

	log_pass "'zfs destroy -f' succeeds as root."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_destroy/zfs_destroy_007_neg.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_destroy/zfs_destroy_007_neg.ksh
	index 70ad45af0488..57eb736fd88b 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_destroy/zfs_destroy_007_neg.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_destroy/zfs_destroy_007_neg.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) 2012, 2016 by Delphix. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/cli_root/zfs_destroy/zfs_destroy.cfg

	#
	# DESCRIPTION:
	# 'zpool destroy' failed if this filesystem is namespace-parent
	# of origin.
	#
	# STRATEGY:
	# 1. Create pool, fs and snapshot.
	# 2. Create a namespace-parent of origin clone.
	# 3. Promote this clone
	# 4. Verify the original fs can not be destroyed.
	#

	verify_runnable "both"

	function cleanup
	{
	if datasetexists $clonesnap; then
	log_must zfs promote $fs
	fi
	- datasetexists $clone && log_must zfs destroy $clone
	- datasetexists $fssnap && log_must zfs destroy $fssnap
	+ datasetexists $clone && destroy_dataset $clone
	+ datasetexists $fssnap && destroy_dataset $fssnap
	}

	log_assert "Destroy dataset which is namespace-parent of origin should failed."
	log_onexit cleanup

	# Define variable $fssnap & and namespace-parent of origin clone.
	fs=$TESTPOOL/$TESTFS
	fssnap=$fs@snap
	clone=$fs/clone
	clonesnap=$fs/clone@snap

	# Define key word for expected failure.
	KEY_WORDS="filesystem has children"

	log_must zfs snapshot $fssnap
	log_must zfs clone $fssnap $clone
	log_must zfs promote $clone
	log_mustnot_expect "$KEY_WORDS" zfs destroy $fs
	log_mustnot_expect "$KEY_WORDS" zfs destroy $clone

	log_pass "Destroy dataset which is namespace-parent of origin passed."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_destroy/zfs_destroy_014_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_destroy/zfs_destroy_014_pos.ksh
	index 58c4cfb5646d..e150cddfa1a5 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_destroy/zfs_destroy_014_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_destroy/zfs_destroy_014_pos.ksh
	@@ -1,79 +1,79 @@
	#!/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) 2012, 2016 by Delphix. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/cli_root/zfs_destroy/zfs_destroy.cfg

	#
	# DESCRIPTION:
	# 'zfs destroy -R <snapshot>' can destroy all the child
	# snapshots and preserves all the nested datasets.
	#
	# STRATEGY:
	# 1. Create nested datasets in the storage pool.
	# 2. Create recursive snapshots for all the nested datasets.
	# 3. Verify when snapshots are destroyed recursively, all
	# the nested datasets still exist.
	#

	verify_runnable "both"

	log_assert "Verify 'zfs destroy -R <snapshot>' does not destroy" \
	"nested datasets."
	log_onexit cleanup

	datasets="$TESTPOOL/$TESTFS1 $TESTPOOL/$TESTFS1/$TESTFS2
	$TESTPOOL/$TESTFS1/$TESTFS2/$TESTFS3"

	function cleanup
	{
	for ds in $datasets; do
	- datasetexists $ds && zfs destroy -rf $ds
	+ datasetexists $ds && destroy_dataset $ds -rf
	done
	}

	# create nested datasets
	log_must zfs create -p $TESTPOOL/$TESTFS1/$TESTFS2/$TESTFS3

	# verify dataset creation
	for ds in $datasets; do
	datasetexists $ds \|\| log_fail "Create $ds dataset fail."
	done

	# create recursive nested snapshot
	log_must zfs snapshot -r $TESTPOOL/$TESTFS1@snap
	for ds in $datasets; do
	datasetexists $ds@snap \|\| log_fail "Create $ds@snap snapshot fail."
	done

	# destroy nested snapshot recursively
	log_must zfs destroy -R $TESTPOOL/$TESTFS1@snap

	# verify snapshot destroy
	for ds in $datasets; do
	datasetexists $ds@snap && log_fail "$ds@snap exists. Destroy failed!"
	done

	# verify nested datasets still exist
	for ds in $datasets; do
	datasetexists $ds \|\| log_fail "Recursive snapshot destroy deleted $ds"
	done

	log_pass "'zfs destroy -R <snapshot>' works as expected."
	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 fb29e4acda14..f1868f522c84 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 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
	+ datasetexists $TESTPOOL/$TESTFS1 && destroy_dataset $TESTPOOL/$TESTFS1 -R
	+ datasetexists $TESTPOOL/$TESTFS2 && destroy_dataset $TESTPOOL/$TESTFS2 -R
	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_destroy/zfs_destroy_016_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_destroy/zfs_destroy_016_pos.ksh
	index 1e129ddd3bc9..93c8c63fd23f 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_destroy/zfs_destroy_016_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_destroy/zfs_destroy_016_pos.ksh
	@@ -1,186 +1,186 @@
	#!/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
	# Verify zfs destroy test for range of snapshots by giving a list
	# of valid and invalid arguments.

	# STRATEGY
	# 1. Create a list of valid and invalid arguments for range snapshot
	# destroy.
	# 2. Set up a filesystem and a volume with multiple snapshots
	# 3. Run zfs destroy for all the arguments and verify existence of snapshots
	# 4. Verify the destroy for snapshots with clones and hold

	. $STF_SUITE/include/libtest.shlib

	function cleanup
	{
	datasetexists $TESTPOOL/$TESTFS1 && \
	- log_must zfs destroy -R $TESTPOOL/$TESTFS1
	+ destroy_dataset $TESTPOOL/$TESTFS1 -R
	datasetexists $TESTPOOL/$TESTVOL && \
	- log_must zfs destroy -Rf $TESTPOOL/$TESTVOL
	+ destroy_dataset $TESTPOOL/$TESTVOL -Rf
	}

	function setup_snapshots
	{
	for i in $snaps; do
	datasetexists $TESTPOOL/$TESTFS1@snap$i && \
	- log_must zfs destroy $TESTPOOL/$TESTFS1@snap$i
	+ destroy_dataset $TESTPOOL/$TESTFS1@snap$i
	datasetexists $TESTPOOL/$TESTVOL@snap$i && \
	- log_must zfs destroy $TESTPOOL/$TESTVOL@snap$i
	+ destroy_dataset $TESTPOOL/$TESTVOL@snap$i
	log_must zfs snapshot $TESTPOOL/$TESTFS1@snap$i
	log_must zfs snapshot $TESTPOOL/$TESTVOL@snap$i
	done
	}

	function verify_snapshots
	{
	typeset snap_exists=${1:-0}
	if [[ $snap_exists == 1 ]]; then
	for i in $range; do
	snapexists $TESTPOOL/$TESTFS1@snap$i \|\| \
	log_fail "zfs destroy should not have destroyed" \
	"$TESTPOOL/$TESTFS1@snap$i"
	snapexists $TESTPOOL/$TESTVOL@snap$i \|\| \
	log_fail "zfs destroy should not have destroyed" \
	"$TESTPOOL/$TESTVOL@snap$i"
	done
	else
	for i in $range; do
	snapexists $TESTPOOL/$TESTFS1@snap$i && \
	log_fail "zfs destroy should have destroyed" \
	"$TESTPOOL/$TESTFS1@snap$i"
	snapexists $TESTPOOL/$TESTVOL@snap$i && \
	log_fail "zfs destroy should have destroyed" \
	"$TESTPOOL/$TESTVOL@snap$i"
	done
	fi
	}

	invalid_args="@snap0%snap5 @snap1%snap6 @snap0%snap6 @snap5%snap1 \
	@snap1%$TESTPOOL/$TESTFS1@snap5 @snap1%%snap5 @snap1%@snap5 \
	@@snap1%snap5 snap1%snap5 snap1%snap3%snap5"
	valid_args="@snap1%snap5 @%"
	log_assert "zfs destroy deletes ranges of snapshots"
	log_onexit cleanup

	log_must zfs create $TESTPOOL/$TESTFS1
	log_must zfs create -V $VOLSIZE $TESTPOOL/$TESTVOL
	snaps="1 2 3 4 5"
	log_note "Verify the valid arguments"
	range="1 2 3 4 5"
	for args in $valid_args; do
	setup_snapshots
	log_must zfs destroy $TESTPOOL/$TESTFS1$args
	log_must zfs destroy $TESTPOOL/$TESTVOL$args
	verify_snapshots
	done

	log_note "Verify invalid arguments"
	setup_snapshots
	for args in $invalid_args; do
	log_mustnot zfs destroy $TESTPOOL/$TESTFS1$args
	log_mustnot zfs destroy $TESTPOOL/$TESTVOL$args
	log_must verify_snapshots 1
	done

	log_note "Destroy the beginning range"

	log_must zfs destroy $TESTPOOL/$TESTFS1@%snap3
	log_must zfs destroy $TESTPOOL/$TESTVOL@%snap3
	range="1 2 3"
	verify_snapshots
	range="4 5"
	verify_snapshots 1

	setup_snapshots
	log_note "Destroy the mid range"
	log_must zfs destroy $TESTPOOL/$TESTFS1@snap2%snap4
	log_must zfs destroy $TESTPOOL/$TESTVOL@snap2%snap4
	range="2 3 4"
	verify_snapshots
	log_must zfs destroy $TESTPOOL/$TESTFS1@snap1%snap5
	log_must zfs destroy $TESTPOOL/$TESTVOL@snap1%snap5
	range="1 5"
	verify_snapshots

	setup_snapshots
	log_note "Destroy the end range"
	log_must zfs destroy $TESTPOOL/$TESTFS1@snap3%
	log_must zfs destroy $TESTPOOL/$TESTVOL@snap3%
	range="1 2"
	verify_snapshots 1
	range="3 4 5"
	verify_snapshots

	setup_snapshots
	log_note "Destroy a simple list"
	log_must zfs destroy $TESTPOOL/$TESTFS1@snap2,snap4
	log_must zfs destroy $TESTPOOL/$TESTVOL@snap2,snap4
	range="2 4"
	verify_snapshots
	range="1 3 5"
	verify_snapshots 1

	setup_snapshots
	log_note "Destroy a list and range together"
	log_must zfs destroy $TESTPOOL/$TESTFS1@snap1%snap3,snap5
	log_must zfs destroy $TESTPOOL/$TESTVOL@snap1%snap3,snap5
	range="1 2 3 5"
	verify_snapshots
	range=4
	verify_snapshots 1

	snaps="1 2 3 5 6 7 8 9 10"
	setup_snapshots
	log_note "Destroy a list of ranges"
	log_must zfs destroy $TESTPOOL/$TESTFS1@snap1%snap3,snap5
	log_must zfs destroy $TESTPOOL/$TESTVOL@snap1%snap3,snap5
	range="1 2 3 5"
	verify_snapshots
	range=4
	verify_snapshots 1

	snaps="1 2 3 4 5"
	setup_snapshots
	log_note "Snapshot destroy with hold"
	range="1 2 3 4 5"
	for i in 1 2 3 4 5; do
	log_must zfs hold keep $TESTPOOL/$TESTFS1@snap$i
	log_must zfs hold keep $TESTPOOL/$TESTVOL@snap$i
	done
	log_mustnot zfs destroy $TESTPOOL/$TESTFS1@snap1%snap5
	log_mustnot zfs destroy $TESTPOOL/$TESTVOL@snap1%snap5
	verify_snapshots 1
	for i in 1 2 3 4 5; do
	log_must zfs release keep $TESTPOOL/$TESTFS1@snap$i
	log_must zfs release keep $TESTPOOL/$TESTVOL@snap$i
	done
	log_must zfs destroy $TESTPOOL/$TESTFS1@snap1%snap5
	log_must zfs destroy $TESTPOOL/$TESTVOL@snap1%snap5
	verify_snapshots

	log_note "Range destroy for snapshots having clones"
	setup_snapshots
	for i in 1 2 3 4 5; do
	log_must zfs clone $TESTPOOL/$TESTFS1@snap$i $TESTPOOL/$TESTFS1/clone$i
	done
	log_must zfs destroy -R $TESTPOOL/$TESTFS1@snap1%snap5
	log_must zfs destroy $TESTPOOL/$TESTVOL@snap1%snap5
	verify_snapshots

	log_pass "'zfs destroy' successfully destroys ranges of snapshots"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_destroy/zfs_destroy_clone_livelist.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_destroy/zfs_destroy_clone_livelist.ksh
	index 2da58ec96cac..e7663ef7973c 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_destroy/zfs_destroy_clone_livelist.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_destroy/zfs_destroy_clone_livelist.ksh
	@@ -1,164 +1,164 @@
	#!/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) 2018, 2020 by Delphix. All rights reserved.
	#

	# DESCRIPTION
	# Verify zfs destroy test for clones with the livelist feature
	# enabled.

	# STRATEGY
	# 1. One clone with an empty livelist
	# - create the clone, check that livelist exists
	# - delete the clone, check that livelist is eventually
	# destroyed
	# 2. One clone with populated livelist
	# - create the clone, check that livelist exists
	# - write multiple files to the clone
	# - delete the clone, check that livelist is eventually
	# destroyed
	# 3. Multiple clones with empty livelists
	# - same as 1. but with multiple clones
	# 4. Multiple clones with populated livelists
	# - same as 2. but with multiple clones
	# 5. Clone of clone with populated livelists with promote

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/cli_root/zfs_destroy/zfs_destroy_common.kshlib

	function cleanup
	{
	- datasetexists $TESTPOOL/$TESTFS1 && zfs destroy -R $TESTPOOL/$TESTFS1
	+ datasetexists $TESTPOOL/$TESTFS1 && destroy_dataset $TESTPOOL/$TESTFS1 -R
	# reset the livelist sublist size to its original value
	set_tunable64 LIVELIST_MAX_ENTRIES $ORIGINAL_MAX
	}

	function clone_write_file
	{
	log_must mkfile 1m /$TESTPOOL/$1/$2
	log_must zpool sync $TESTPOOL
	}

	function test_one_empty
	{
	clone_dataset $TESTFS1 snap $TESTCLONE

	log_must zfs destroy $TESTPOOL/$TESTCLONE
	check_livelist_gone
	}

	function test_one
	{
	clone_dataset $TESTFS1 snap $TESTCLONE

	clone_write_file $TESTCLONE $TESTFILE0
	clone_write_file $TESTCLONE $TESTFILE1
	clone_write_file $TESTCLONE $TESTFILE2
	log_must rm /$TESTPOOL/$TESTCLONE/$TESTFILE0
	log_must rm /$TESTPOOL/$TESTCLONE/$TESTFILE2
	check_livelist_exists $TESTCLONE

	log_must zfs destroy $TESTPOOL/$TESTCLONE
	check_livelist_gone
	}

	function test_multiple_empty
	{
	clone_dataset $TESTFS1 snap $TESTCLONE
	clone_dataset $TESTFS1 snap $TESTCLONE1
	clone_dataset $TESTFS1 snap $TESTCLONE2

	log_must zfs destroy $TESTPOOL/$TESTCLONE
	log_must zfs destroy $TESTPOOL/$TESTCLONE1
	log_must zfs destroy $TESTPOOL/$TESTCLONE2
	check_livelist_gone
	}

	function test_multiple
	{
	clone_dataset $TESTFS1 snap $TESTCLONE
	clone_dataset $TESTFS1 snap $TESTCLONE1
	clone_dataset $TESTFS1 snap $TESTCLONE2

	clone_write_file $TESTCLONE $TESTFILE0

	clone_write_file $TESTCLONE1 $TESTFILE0
	clone_write_file $TESTCLONE1 $TESTFILE1
	clone_write_file $TESTCLONE1 $TESTFILE2

	clone_write_file $TESTCLONE2 $TESTFILE0
	log_must rm /$TESTPOOL/$TESTCLONE2/$TESTFILE0
	clone_write_file $TESTCLONE2 $TESTFILE1
	log_must rm /$TESTPOOL/$TESTCLONE2/$TESTFILE1

	check_livelist_exists $TESTCLONE
	check_livelist_exists $TESTCLONE1
	check_livelist_exists $TESTCLONE2

	log_must zfs destroy $TESTPOOL/$TESTCLONE
	log_must zfs destroy $TESTPOOL/$TESTCLONE1
	log_must zfs destroy $TESTPOOL/$TESTCLONE2
	check_livelist_gone
	}

	function test_promote
	{
	clone_dataset $TESTFS1 snap $TESTCLONE

	log_must zfs promote $TESTPOOL/$TESTCLONE
	check_livelist_gone
	log_must zfs destroy -R $TESTPOOL/$TESTCLONE
	}

	function test_clone_clone_promote
	{
	log_must zfs create $TESTPOOL/fs
	log_must dd if=/dev/zero of=/$TESTPOOL/fs/file bs=128k count=100
	log_must zfs snapshot $TESTPOOL/fs@snap
	log_must zfs clone $TESTPOOL/fs@snap $TESTPOOL/clone
	log_must dd if=/dev/zero of=/$TESTPOOL/clone/clonefile bs=128k count=10
	log_must zfs snapshot $TESTPOOL/clone@csnap
	log_must zfs clone $TESTPOOL/clone@csnap $TESTPOOL/cloneclone

	check_livelist_exists clone
	check_livelist_exists cloneclone

	# Promote should remove both clones' livelists
	log_must zfs promote $TESTPOOL/cloneclone
	check_livelist_gone

	# This destroy should not use a livelist
	log_must zfs destroy $TESTPOOL/clone
	log_must zdb -bcc $TESTPOOL
	}

	ORIGINAL_MAX=$(get_tunable LIVELIST_MAX_ENTRIES)

	log_onexit cleanup
	log_must zfs create $TESTPOOL/$TESTFS1
	log_must mkfile 20m /$TESTPOOL/$TESTFS1/atestfile
	log_must zfs snapshot $TESTPOOL/$TESTFS1@snap

	# set a small livelist entry size to more easily test multiple entry livelists
	set_tunable64 LIVELIST_MAX_ENTRIES 20

	test_one_empty
	test_one
	test_multiple_empty
	test_multiple
	test_promote
	test_clone_clone_promote

	log_pass "Clone with the livelist feature enabled could be destroyed," \
	"also could be promoted and destroyed as expected."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_destroy/zfs_destroy_common.kshlib b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_destroy/zfs_destroy_common.kshlib
	index 096c18f069ff..1a20b7a33131 100644
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_destroy/zfs_destroy_common.kshlib
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_destroy/zfs_destroy_common.kshlib
	@@ -1,174 +1,172 @@
	#
	# 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) 2012, 2018 by Delphix. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/cli_root/zfs_destroy/zfs_destroy.cfg

	#
	# Create or recover a set of test environment which include ctr, vol, fs,
	# snap & clone. It looks like the following.
	#
	# pool
	# \|ctr
	# \| \|fs
	# \| \| \|fssnap
	# \| \|vol
	# \| \|volsnap
	# \|fsclone
	# \|volclone
	#
	# $1 indicate which dependent dataset need be created. Such as 'snap', 'clone'.
	#
	function setup_testenv #[dtst]
	{
	typeset dtst=$1

	if ! datasetexists $CTR; then
	log_must zfs create $CTR
	fi
	if ! datasetexists $FS; then
	log_must zfs create $FS
	fi
	# Volume test is only available on global zone
	if ! datasetexists $VOL && is_global_zone; then
	log_must zfs create -V $VOLSIZE $VOL
	block_device_wait

	log_must new_fs $ZVOL_DEVDIR/$VOL

	if [[ ! -d $TESTDIR1 ]]; then
	log_must mkdir $TESTDIR1
	fi
	log_must mount $ZVOL_DEVDIR/$VOL $TESTDIR1
	fi

	if [[ $dtst == snap \|\| $dtst == clone ]]; then
	if ! datasetexists $FSSNAP; then
	log_must zfs snapshot $FSSNAP
	fi
	if ! datasetexists $VOLSNAP && is_global_zone; then
	log_must zfs snapshot $VOLSNAP
	fi
	fi

	if [[ $dtst == clone ]]; then
	if ! datasetexists $FSCLONE; then
	log_must zfs clone $FSSNAP $FSCLONE
	fi
	if ! datasetexists $VOLCLONE && is_global_zone; then
	log_must zfs clone $VOLSNAP $VOLCLONE
	block_device_wait
	fi
	fi
	}

	# Clean up the testing environment
	#
	function cleanup_testenv
	{
	if is_global_zone && ismounted "$TESTDIR1" "$NEWFS_DEFAULT_FS" ; then
	log_must umount -f $TESTDIR1
	fi
	if [[ -d $TESTDIR1 ]]; then
	log_must rm -rf $TESTDIR1
	fi

	pkill mkbusy

	- if datasetexists $CTR; then
	- log_must zfs destroy -Rf $CTR
	- fi
	+ datasetexists $CTR && destroy_dataset $CTR -Rf
	}

	#
	# Delete volume and related datasets from list, if the test cases was
	# running in local zone. Then check them are existed or non-exists.
	#
	# $1 function name
	# $2-n datasets name
	#
	function check_dataset
	{
	typeset funname=$1
	typeset newlist=""
	typeset dtst
	shift

	for dtst in "$@"; do
	# Volume and related stuff are unavailable in local zone
	if ! is_global_zone; then
	if [[ $dtst == $VOL \|\| $dtst == $VOLSNAP \|\| \
	$dtst == $VOLCLONE ]]
	then
	continue
	fi
	fi
	newlist="$newlist $dtst"
	done

	if (( ${#newlist} != 0 )); then
	# Run each item in $newlist individually so on failure, the
	# problematic dataset is listed in the logs.
	for i in $newlist; do
	log_must $funname $i
	done
	fi
	}

	# Use zdb to see if a livelist exists for a given clone
	# $1 clone name
	function check_livelist_exists
	{
	zdb -vvvvv $TESTPOOL/$1 \| grep "Livelist" \|\| \
	log_fail "zdb could not find Livelist"
	}

	# Check that a livelist has been removed, waiting for deferred destroy entries
	# to be cleared from zdb.
	function check_livelist_gone
	{
	log_must zpool wait -t free $TESTPOOL
	zpool sync
	zdb -vvvvv $TESTPOOL \| grep "Livelist" && \
	log_fail "zdb found Livelist after the clone is deleted."
	}

	# Create a clone in the testpool based on $TESTFS@snap. Verify that the clone
	# was created and that it includes a livelist
	# $1 fs name
	# $2 snap name
	# $3 clone name
	function clone_dataset
	{
	log_must zfs clone $TESTPOOL/$1@$2 $TESTPOOL/$3
	datasetexists $TESTPOOL/$3 \|\| \
	log_fail "zfs clone $TESTPOOL/$3 fail."
	check_livelist_exists $3
	}
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_diff/zfs_diff_cliargs.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_diff/zfs_diff_cliargs.ksh
	index c4b42afee472..7063bbe9ce6a 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_diff/zfs_diff_cliargs.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_diff/zfs_diff_cliargs.ksh
	@@ -1,80 +1,78 @@
	#!/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 2017, loli10K <ezomori.nozomu@gmail.com>. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib

	#
	# DESCRIPTION:
	# 'zfs diff' should only work with supported options.
	#
	# STRATEGY:
	# 1. Create two snapshots
	# 2. Verify every supported option is accepted
	# 3. Verify supported options raise an error with unsupported arguments
	# 4. Verify other unsupported options raise an error
	#

	verify_runnable "both"

	function cleanup
	{
	for snap in $TESTSNAP1 $TESTSNAP2; do
	- if snapexists "$snap"; then
	- log_must zfs destroy "$snap"
	- fi
	+ snapexists "$snap" && destroy_dataset "$snap"
	done
	}

	log_assert "'zfs diff' should only work with supported options."
	log_onexit cleanup

	typeset goodopts=("" "-F" "-H" "-t" "-FH" "-Ft" "-Ht" "-FHt")
	typeset badopts=("-f" "-h" "-h" "-T" "-Fx" "-Ho" "-tT" "-")

	DATASET="$TESTPOOL/$TESTFS"
	TESTSNAP1="$DATASET@snap1"
	TESTSNAP2="$DATASET@snap2"

	# 1. Create two snapshots
	log_must zfs snapshot "$TESTSNAP1"
	log_must zfs snapshot "$TESTSNAP2"

	# 2. Verify every supported option is accepted
	for opt in ${goodopts[@]}
	do
	log_must zfs diff $opt "$TESTSNAP1"
	log_must zfs diff $opt "$TESTSNAP1" "$DATASET"
	log_must zfs diff $opt "$TESTSNAP1" "$TESTSNAP2"
	done

	# 3. Verify supported options raise an error with unsupported arguments
	for opt in ${goodopts[@]}
	do
	log_mustnot zfs diff $opt
	log_mustnot zfs diff $opt "$DATASET"
	log_mustnot zfs diff $opt "$DATASET@noexists"
	log_mustnot zfs diff $opt "$DATASET" "$TESTSNAP1"
	log_mustnot zfs diff $opt "$TESTSNAP2" "$TESTSNAP1"
	done

	# 4. Verify other unsupported options raise an error
	for opt in ${badopts[@]}
	do
	log_mustnot zfs diff $opt "$TESTSNAP1" "$DATASET"
	log_mustnot zfs diff $opt "$TESTSNAP1" "$TESTSNAP2"
	done

	log_pass "'zfs diff' only works with supported options."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_diff/zfs_diff_timestamp.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_diff/zfs_diff_timestamp.ksh
	index 62c4e768c0a1..0d08cf629572 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_diff/zfs_diff_timestamp.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_diff/zfs_diff_timestamp.ksh
	@@ -1,100 +1,98 @@
	#!/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 2017, loli10K <ezomori.nozomu@gmail.com>. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib

	#
	# DESCRIPTION:
	# 'zfs diff -t' should display inode change time correctly.
	#
	# STRATEGY:
	# 1. Create a snapshot
	# 2. Create some files with a random delay and snapshot the filesystem again
	# 3. Verify 'zfs diff -t' correctly display timestamps
	#

	verify_runnable "both"

	function cleanup
	{
	for snap in $TESTSNAP1 $TESTSNAP2; do
	- if snapexists "$snap"; then
	- log_must zfs destroy "$snap"
	- fi
	+ snapexists "$snap" && destroy_dataset "$snap"
	done
	find "$MNTPOINT" -type f -delete
	rm -f "$FILEDIFF"
	}

	#
	# Creates $count files in $fspath. Waits a random delay between each file.
	#
	function create_random # <fspath> <count>
	{
	fspath="$1"
	typeset -i count="$2"
	typeset -i i=0

	while (( i < count )); do
	log_must touch "$fspath/file$i"
	sleep $(random_int_between 1 3)
	(( i = i + 1 ))
	done
	}

	log_assert "'zfs diff -t' should display inode change time correctly."
	log_onexit cleanup

	DATASET="$TESTPOOL/$TESTFS"
	TESTSNAP1="$DATASET@snap1"
	TESTSNAP2="$DATASET@snap2"
	MNTPOINT="$(get_prop mountpoint $DATASET)"
	FILEDIFF="$TESTDIR/zfs-diff.txt"
	FILENUM=5

	# 1. Create a snapshot
	log_must zfs snapshot "$TESTSNAP1"

	# 2. Create some files with a random delay and snapshot the filesystem again
	create_random "$MNTPOINT" $FILENUM
	log_must zfs snapshot "$TESTSNAP2"

	# 3. Verify 'zfs diff -t' correctly display timestamps
	typeset -i count=0
	log_must eval "zfs diff -t $TESTSNAP1 $TESTSNAP2 > $FILEDIFF"
	awk '{print substr($1,1,index($1,".")-1)" "$NF}' < "$FILEDIFF" \| while read line
	do
	read ctime file <<< "$line"

	# If path from 'zfs diff' is not a file (could be xattr object) skip it
	if [[ ! -f "$file" ]]; then
	continue;
	fi

	filetime=$(stat_ctime $file)
	if [[ "$filetime" != "$ctime" ]]; then
	log_fail "Unexpected ctime for file $file ($filetime != $ctime)"
	else
	log_note "Correct ctime read on $file: $ctime"
	fi

	(( i = i + 1 ))
	done
	if [[ $i != $FILENUM ]]; then
	log_fail "Wrong number of files verified ($i != $FILENUM)"
	fi

	log_pass "'zfs diff -t' displays inode change time correctly."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_get/zfs_get_004_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_get/zfs_get_004_pos.ksh
	index 4bd61137c7be..3bc4c6240ed3 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_get/zfs_get_004_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_get/zfs_get_004_pos.ksh
	@@ -1,227 +1,224 @@
	#!/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) 2012, 2016 by Delphix. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib

	#
	# DESCRIPTION:
	# Verify 'zfs get all' can get all properties for all datasets in the system
	#
	# STRATEGY:
	# 1. Create datasets for testing
	# 2. Issue 'zfs get all' command
	# 3. Verify the command gets all available properties of all datasets
	#

	verify_runnable "both"

	function cleanup
	{
	[[ -e $propfile ]] && rm -f $propfile

	- datasetexists $clone && \
	- log_must zfs destroy $clone
	+ datasetexists $clone && destroy_dataset $clone
	for snap in $fssnap $volsnap ; do
	- snapexists $snap && \
	- log_must zfs destroy $snap
	+ snapexists $snap && destroy_dataset $snap
	done

	if [[ -n $globalzone ]] ; then
	for pool in $TESTPOOL1 $TESTPOOL2 $TESTPOOL3; do
	poolexists $pool && \
	log_must zpool destroy -f $pool
	done
	for file in `ls $TESTDIR1/poolfile*`; do
	rm -f $file
	done
	else
	for fs in $TESTPOOL/$TESTFS1 $TESTPOOL/$TESTFS2 $TESTPOOL/$TESTFS3; do
	- datasetexists $fs && \
	- log_must zfs destroy -rf $fs
	+ datasetexists $fs && destroy_dataset $fs -rf
	done
	fi
	}

	log_assert "Verify the functions of 'zfs get all' work."
	log_onexit cleanup

	typeset globalzone=""

	if is_global_zone ; then
	globalzone="true"
	fi

	set -A opts "" "-r" "-H" "-p" "-rHp" "-o name" \
	"-s local,default,temporary,inherited,none" \
	"-o name -s local,default,temporary,inherited,none" \
	"-rHp -o name -s local,default,temporary,inherited,none"
	set -A usrprops "a:b=c" "d_1:1_e=0f" "123:456=789"

	fs=$TESTPOOL/$TESTFS
	fssnap=$fs@$TESTSNAP
	clone=$TESTPOOL/$TESTCLONE
	volsnap=$TESTPOOL/$TESTVOL@$TESTSNAP

	#set user defined properties for $TESTPOOL
	for usrprop in ${usrprops[@]}; do
	log_must zfs set $usrprop $TESTPOOL
	done
	# create snapshot and clone in $TESTPOOL
	log_must zfs snapshot $fssnap
	log_must zfs clone $fssnap $clone
	log_must zfs snapshot $volsnap

	# collect datasets which can be set user defined properties
	usrpropds="$clone $fs"

	# collect all datasets which we are creating
	allds="$fs $clone $fssnap $volsnap"

	#create pool and datasets to guarantee testing under multiple pools and datasets.
	file=$TESTDIR1/poolfile
	typeset FILESIZE=$MINVDEVSIZE
	(( DFILESIZE = $FILESIZE * 2 ))
	typeset -i VOLSIZE=10485760
	availspace=$(get_prop available $TESTPOOL)
	typeset -i i=0

	# make sure 'availspace' is larger then twice of FILESIZE to create a new pool.
	# If any, we only totally create 3 pools for multiple datasets testing to limit
	# testing time
	while (( availspace > DFILESIZE )) && (( i < 3 )) ; do
	(( i += 1 ))

	if [[ -n $globalzone ]] ; then
	log_must mkfile $FILESIZE ${file}$i
	eval pool=\$TESTPOOL$i
	log_must zpool create $pool ${file}$i
	else
	eval pool=$TESTPOOL/\$TESTFS$i
	log_must zfs create $pool
	fi

	#set user defined properties for testing
	for usrprop in ${usrprops[@]}; do
	log_must zfs set $usrprop $pool
	done

	#create datasets in pool
	log_must zfs create $pool/$TESTFS
	log_must zfs snapshot $pool/$TESTFS@$TESTSNAP
	log_must zfs clone $pool/$TESTFS@$TESTSNAP $pool/$TESTCLONE

	if [[ -n $globalzone ]] ; then
	log_must zfs create -V $VOLSIZE $pool/$TESTVOL
	else
	log_must zfs create $pool/$TESTVOL
	fi

	ds=`zfs list -H -r -o name -t filesystem,volume $pool`
	usrpropds="$usrpropds $pool/$TESTFS $pool/$TESTCLONE $pool/$TESTVOL"
	allds="$allds $pool/$TESTFS $pool/$TESTCLONE $pool/$TESTVOL \
	$pool/$TESTFS@$TESTSNAP"

	availspace=$(get_prop available $TESTPOOL)
	done

	#the expected number of property for each type of dataset in this testing
	typeset -i fspropnum=27
	typeset -i snappropnum=8
	typeset -i volpropnum=15
	propfile=$TEST_BASE_DIR/allpropfile.$$

	typeset -i i=0
	typeset -i propnum=0
	typeset -i failflag=0
	while (( i < ${#opts[*]} )); do
	[[ -e $propfile ]] && rm -f $propfile
	log_must eval "zfs get ${opts[i]} all >$propfile"

	for ds in $allds; do
	grep $ds $propfile >/dev/null 2>&1
	(( $? != 0 )) && \
	log_fail "There is no property for" \
	"dataset $ds in 'get all' output."

	propnum=`cat $propfile \| awk '{print $1}' \| \
	grep "${ds}$" \| wc -l`
	ds_type=`zfs get -H -o value type $ds`
	case $ds_type in
	filesystem )
	(( propnum < fspropnum )) && \
	(( failflag += 1 ))
	;;
	snapshot )
	(( propnum < snappropnum )) && \
	(( failflag += 1 ))
	;;
	volume )
	(( propnum < volpropnum )) && \
	(( failflag += 1 ))
	;;
	esac

	(( failflag != 0 )) && \
	log_fail " 'zfs get all' fails to get out " \
	"all properties for dataset $ds."

	(( propnum = 0 ))
	(( failflag = 0 ))
	done

	(( i += 1 ))
	done

	log_note "'zfs get' can get particular property for all datasets with that property."

	function do_particular_prop_test #<property> <suitable datasets>
	{
	typeset props="$1"
	typeset ds="$2"

	for prop in ${commprops[*]}; do
	ds=`zfs get -H -o name $prop`

	[[ "$ds" != "$allds" ]] && \
	log_fail "The result datasets are $ds, but all suitable" \
	"datasets are $allds for the property $prop"
	done
	}

	# Here, we do a testing for user defined properties and the most common properties
	# for all datasets.
	commprop="type creation used referenced compressratio"
	usrprop="a:b d_1:1_e 123:456"

	do_particular_prop_test "$commprop" "$allds"
	do_particular_prop_test "$usrprop" "$usrpropds"

	log_pass "'zfs get all' works as expected."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_get/zfs_get_list_d.kshlib b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_get/zfs_get_list_d.kshlib
	index 48b3268f7813..d5388e6ef2ae 100644
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_get/zfs_get_list_d.kshlib
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_get/zfs_get_list_d.kshlib
	@@ -1,84 +1,82 @@
	#
	# 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.
	#

	. $STF_SUITE/include/libtest.shlib

	DEPTH_FS=$TESTPOOL/depth_fs
	MAX_DEPTH=3
	DS_COUNT=3
	set -A depth_options "d 0" "d 1" "d 2" "d 4" "d 32"
	set -A depth_array 0 1 2 4 32

	#
	# Setup multiple depths datasets, including fs, volumes, snapshots and bookmarks.
	#
	function depth_fs_setup
	{
	typeset -i i j k
	typeset fslist

	log_must zfs create $DEPTH_FS

	(( i=1 ))
	while (( i<=MAX_DEPTH )); do
	if (( i==1 )); then
	fslist=$DEPTH_FS
	else
	(( k=i-1 ))
	fslist=$(zfs list -rH -t filesystem -o name $DEPTH_FS\|grep depth"$k"$)
	if (( $? != 0 )); then
	log_fail "No depth$k filesystem"
	fi
	fi
	for fs in $fslist; do
	(( j=1 ))
	while (( j<=DS_COUNT )); do
	log_must zfs create $fs/fs_"$j"_depth"$i"
	if is_global_zone ; then
	log_must zfs create -V 8M $fs/vol_"$j"_depth"$i"
	fi
	log_must zfs snapshot $fs@snap_"$j"_depth"$i"
	log_must zfs bookmark $fs@snap_"$j"_depth"$i" '#bookmark'_"$j"_depth"$i"
	(( j=j+1 ))
	done
	done
	(( i=i+1 ))
	done
	}

	#
	# Cleanup multiple depths filesystem.
	#
	function depth_fs_cleanup
	{
	- log_must zfs destroy -rR $DEPTH_FS
	+ datasetexists $DEPTH_FS && destroy_dataset $DEPTH_FS -rR
	}
	-
	-
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_inherit/zfs_inherit_002_neg.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_inherit/zfs_inherit_002_neg.ksh
	index 61f22ea091d1..8e37e8dbcae0 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_inherit/zfs_inherit_002_neg.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_inherit/zfs_inherit_002_neg.ksh
	@@ -1,107 +1,106 @@
	#!/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) 2011, 2016 by Delphix. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib

	#
	# DESCRIPTION:
	# 'zfs inherit' should return an error with bad parameters in one command.
	#
	# STRATEGY:
	# 1. Set an array of bad options and invalid properties to 'zfs inherit'
	# 2. Execute 'zfs inherit' with bad options and passing invalid properties
	# 3. Verify an error is returned.
	#

	verify_runnable "both"

	function cleanup
	{
	- if snapexists $TESTPOOL/$TESTFS@$TESTSNAP; then
	- log_must zfs destroy $TESTPOOL/$TESTFS@$TESTSNAP
	- fi
	+ snapexists $TESTPOOL/$TESTFS@$TESTSNAP && \
	+ destroy_dataset $TESTPOOL/$TESTFS@$TESTSNAP
	}

	log_assert "'zfs inherit' should return an error with bad parameters in" \
	"one command."
	log_onexit cleanup

	set -A badopts "r" "R" "-R" "-rR" "-a" "-" "-?" "-1" "-2" "-v" "-n"
	set -A props "recordsize" "mountpoint" "sharenfs" "checksum" "compression" \
	"atime" "devices" "exec" "setuid" "readonly" "snapdir" "aclmode" \
	"aclinherit" "xattr" "copies"
	if is_freebsd; then
	props+=("jailed")
	else
	props+=("zoned")
	fi
	set -A illprops "recordsiz" "mountpont" "sharen" "compres" "atme" "blah"

	log_must zfs snapshot $TESTPOOL/$TESTFS@$TESTSNAP

	typeset -i i=0
	for ds in $TESTPOOL $TESTPOOL/$TESTFS $TESTPOOL/$TESTVOL \
	$TESTPOOL/$TESTFS@$TESTSNAP; do

	# zfs inherit should fail with bad options
	for opt in ${badopts[@]}; do
	for prop in ${props[@]}; do
	log_mustnot eval "zfs inherit $opt $prop $ds \
	>/dev/null 2>&1"
	done
	done

	# zfs inherit should fail with invalid properties
	for prop in "${illprops[@]}"; do
	log_mustnot eval "zfs inherit $prop $ds >/dev/null 2>&1"
	log_mustnot eval "zfs inherit -r $prop $ds >/dev/null 2>&1"
	done

	# zfs inherit should fail with too many arguments
	(( i = 0 ))
	while (( i < ${#props[*]} -1 )); do
	log_mustnot eval "zfs inherit ${props[(( i ))]} \
	${props[(( i + 1 ))]} $ds >/dev/null 2>&1"
	log_mustnot eval "zfs inherit -r ${props[(( i ))]} \
	${props[(( i + 1 ))]} $ds >/dev/null 2>&1"

	(( i = i + 2 ))
	done

	done

	# zfs inherit should fail with missing datasets
	for prop in ${props[@]}; do
	log_mustnot eval "zfs inherit $prop >/dev/null 2>&1"
	log_mustnot eval "zfs inherit -r $prop >/dev/null 2>&1"
	done

	log_pass "'zfs inherit' failed as expected when passing illegal arguments."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_inherit/zfs_inherit_003_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_inherit/zfs_inherit_003_pos.ksh
	index 3317b09e2b5b..3f7e4ff972ed 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_inherit/zfs_inherit_003_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_inherit/zfs_inherit_003_pos.ksh
	@@ -1,90 +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 2009 Sun Microsystems, Inc. All rights reserved.
	# Use is subject to license terms.
	#

	#
	# Copyright (c) 2016 by Delphix. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/cli_root/zfs_set/zfs_set_common.kshlib

	#
	# DESCRIPTION:
	# 'zfs inherit' should return an error with bad parameters in one command.
	#
	# STRATEGY:
	# 1. Set an array of bad options and invalid properties to 'zfs inherit'
	# 2. Execute 'zfs inherit' with bad options and passing invalid properties
	# 3. Verify an error is returned.
	#

	verify_runnable "both"

	function cleanup
	{
	for ds in $TESTPOOL $TESTPOOL/$TESTFS $TESTPOOL/$TESTVOL ; do
	- if snapexists $ds@$TESTSNAP; then
	- log_must zfs destroy $ds@$TESTSNAP
	- fi
	+ snapexists $ds@$TESTSNAP && destroy_dataset $ds@$TESTSNAP
	done
	cleanup_user_prop $TESTPOOL
	}

	log_assert "'zfs inherit' should inherit user property."
	log_onexit cleanup

	for ds in $TESTPOOL $TESTPOOL/$TESTFS $TESTPOOL/$TESTVOL ; do
	typeset prop_name=$(valid_user_property 10)
	typeset value=$(user_property_value 16)

	log_must eval "zfs set $prop_name='$value' $ds"

	log_must zfs snapshot $ds@$TESTSNAP

	typeset snapvalue=$(get_prop $prop_name $ds@$TESTSNAP)

	if [[ "$snapvalue" != "$value" ]] ; then
	log_fail "The '$ds@$TESTSNAP '$prop_name' value '$snapvalue' " \
	"not equal to the expected value '$value'."
	fi

	snapvalue=$(user_property_value 16)
	log_must eval "zfs set $prop_name='$snapvalue' $ds@$TESTSNAP"

	log_must zfs inherit $prop_name $ds@$TESTSNAP

	snapvalue=$(get_prop $prop_name $ds@$TESTSNAP)

	if [[ "$snapvalue" != "$value" ]] ; then
	log_fail "The '$ds@$TESTSNAP '$prop_name' value '$snapvalue' " \
	"not equal to the expected value '$value'."
	fi


	done

	log_pass "'zfs inherit' inherit user property."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_load-key/zfs_load-key.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_load-key/zfs_load-key.ksh
	index 847a6aabd3c8..8af9f80cfbd7 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_load-key/zfs_load-key.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_load-key/zfs_load-key.ksh
	@@ -1,85 +1,85 @@
	#!/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) 2017 Datto, Inc. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/cli_root/zfs_load-key/zfs_load-key_common.kshlib

	#
	# DESCRIPTION:
	# 'zfs load-key' should only load a key for an unloaded encrypted dataset.
	#
	# STRATEGY:
	# 1. Attempt to load the default dataset's key
	# 2. Unmount the dataset
	# 3. Attempt to load the default dataset's key
	# 4. Create an encrypted dataset
	# 5. Unmount the dataset and unload its key
	# 6. Attempt to load the dataset's key
	# 7. Verify the dataset's key is loaded
	# 8. Attempt to load the dataset's key again
	# 9. Create an encrypted pool
	# 10. Unmount the pool and unload its key
	# 11. Attempt to load the pool's key
	# 12. Verify the pool's key is loaded
	# 13. Attempt to load the pool's key again
	#

	verify_runnable "both"

	function cleanup
	{
	datasetexists $TESTPOOL/$TESTFS1 && \
	- log_must zfs destroy $TESTPOOL/$TESTFS1
	+ destroy_dataset $TESTPOOL/$TESTFS1
	poolexists $TESTPOOL1 && log_must destroy_pool $TESTPOOL1
	}
	log_onexit cleanup

	log_assert "'zfs load-key' should only load the key for an" \
	"unloaded encrypted dataset"

	log_mustnot eval "echo $PASSPHRASE \| zfs load-key $TESTPOOL/$TESTFS"

	log_must zfs unmount $TESTPOOL/$TESTFS
	log_mustnot eval "echo $PASSPHRASE \| zfs load-key $TESTPOOL/$TESTFS"

	log_must eval "echo $PASSPHRASE \| zfs create -o encryption=on" \
	"-o keyformat=passphrase -o keylocation=prompt $TESTPOOL/$TESTFS1"

	log_must zfs unmount $TESTPOOL/$TESTFS1
	log_must zfs unload-key $TESTPOOL/$TESTFS1

	log_must eval "echo $PASSPHRASE \| zfs load-key $TESTPOOL/$TESTFS1"
	log_must key_available $TESTPOOL/$TESTFS1

	log_mustnot eval "echo $PASSPHRASE \| zfs load-key $TESTPOOL/$TESTFS1"

	typeset DISK2="$(echo $DISKS \| awk '{ print $2 }')"
	log_must eval "echo $PASSPHRASE \| zpool create -O encryption=on" \
	"-O keyformat=passphrase -O keylocation=prompt $TESTPOOL1 $DISK2"

	log_must zfs unmount $TESTPOOL1
	log_must zfs unload-key $TESTPOOL1

	log_must eval "echo $PASSPHRASE \| zfs load-key $TESTPOOL1"
	log_must key_available $TESTPOOL1

	log_mustnot eval "echo $PASSPHRASE \| zfs load-key $TESTPOOL1"

	log_pass "'zfs load-key' only loads the key for an unloaded encrypted dataset"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_load-key/zfs_load-key_all.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_load-key/zfs_load-key_all.ksh
	index 5e331fd1200d..5e330eb0deb9 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_load-key/zfs_load-key_all.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_load-key/zfs_load-key_all.ksh
	@@ -1,77 +1,76 @@
	#!/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) 2017 Datto, Inc. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/cli_root/zfs_load-key/zfs_load-key_common.kshlib

	#
	# DESCRIPTION:
	# 'zfs load-key -a' should load keys for all datasets.
	#
	# STRATEGY:
	# 1. Create an encrypted filesystem, encrypted zvol, and an encrypted pool
	# 2. Unmount all datasets and unload their keys
	# 3. Attempt to load all dataset keys
	# 4. Verify each dataset has its key loaded
	# 5. Attempt to mount the pool and filesystem
	#

	verify_runnable "both"

	function cleanup
	{
	- datasetexists $TESTPOOL/$TESTFS1 && \
	- log_must zfs destroy $TESTPOOL/$TESTFS1
	- datasetexists $TESTPOOL/zvol && log_must zfs destroy $TESTPOOL/zvol
	+ datasetexists $TESTPOOL/$TESTFS1 && destroy_dataset $TESTPOOL/$TESTFS1
	+ datasetexists $TESTPOOL/zvol && destroy_dataset $TESTPOOL/zvol
	poolexists $TESTPOOL1 && log_must destroy_pool $TESTPOOL1
	}
	log_onexit cleanup

	log_assert "'zfs load-key -a' should load keys for all datasets"

	log_must eval "echo $PASSPHRASE1 > /$TESTPOOL/pkey"
	log_must zfs create -o encryption=on -o keyformat=passphrase \
	-o keylocation=file:///$TESTPOOL/pkey $TESTPOOL/$TESTFS1

	log_must zfs create -V 64M -o encryption=on -o keyformat=passphrase \
	-o keylocation=file:///$TESTPOOL/pkey $TESTPOOL/zvol

	typeset DISK2="$(echo $DISKS \| awk '{ print $2}')"
	log_must zpool create -O encryption=on -O keyformat=passphrase \
	-O keylocation=file:///$TESTPOOL/pkey $TESTPOOL1 $DISK2

	log_must zfs unmount $TESTPOOL/$TESTFS1
	-log_must zfs unload-key $TESTPOOL/$TESTFS1
	+log_must_busy zfs unload-key $TESTPOOL/$TESTFS1

	-log_must zfs unload-key $TESTPOOL/zvol
	+log_must_busy zfs unload-key $TESTPOOL/zvol

	log_must zfs unmount $TESTPOOL1
	-log_must zfs unload-key $TESTPOOL1
	+log_must_busy zfs unload-key $TESTPOOL1

	log_must zfs load-key -a

	log_must key_available $TESTPOOL1
	log_must key_available $TESTPOOL/zvol
	log_must key_available $TESTPOOL/$TESTFS1

	log_must zfs mount $TESTPOOL1
	log_must zfs mount $TESTPOOL/$TESTFS1

	log_pass "'zfs load-key -a' loads keys for all datasets"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_load-key/zfs_load-key_file.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_load-key/zfs_load-key_file.ksh
	index 7cbda43ff241..73c461fd6b39 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_load-key/zfs_load-key_file.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_load-key/zfs_load-key_file.ksh
	@@ -1,58 +1,58 @@
	#!/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) 2017 Datto, Inc. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/cli_root/zfs_load-key/zfs_load-key_common.kshlib

	#
	# DESCRIPTION:
	# 'zfs load-key' should load a dataset's key from a file.
	#
	# STRATEGY:
	# 1. Create an encrypted dataset with a key file
	# 2. Unmount the dataset and unload the key
	# 3. Attempt to load the dataset's key
	# 4. Verify the key is loaded
	# 5. Attempt to mount the dataset
	#

	verify_runnable "both"

	function cleanup
	{
	datasetexists $TESTPOOL/$TESTFS1 && \
	- log_must zfs destroy $TESTPOOL/$TESTFS1
	+ destroy_dataset $TESTPOOL/$TESTFS1
	}
	log_onexit cleanup

	log_assert "'zfs load-key' should load a key from a file"

	log_must eval "echo $PASSPHRASE > /$TESTPOOL/pkey"
	log_must zfs create -o encryption=on -o keyformat=passphrase \
	-o keylocation=file:///$TESTPOOL/pkey $TESTPOOL/$TESTFS1

	log_must zfs unmount $TESTPOOL/$TESTFS1
	log_must zfs unload-key $TESTPOOL/$TESTFS1

	log_must zfs load-key $TESTPOOL/$TESTFS1
	log_must key_available $TESTPOOL/$TESTFS1
	log_must zfs mount $TESTPOOL/$TESTFS1

	log_pass "'zfs load-key' loads a key from a file"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_load-key/zfs_load-key_location.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_load-key/zfs_load-key_location.ksh
	index d0b1cdb20ec7..8538143cb62e 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_load-key/zfs_load-key_location.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_load-key/zfs_load-key_location.ksh
	@@ -1,73 +1,73 @@
	#!/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) 2017 Datto, Inc. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/cli_root/zfs_load-key/zfs_load-key_common.kshlib

	#
	# DESCRIPTION:
	# 'zfs load-key -L' should override keylocation with provided value.
	#
	# STRATEGY:
	# 1. Create a key file
	# 2. Copy the key file to another location
	# 3. Create an encrypted dataset using the keyfile
	# 4. Unmount the dataset and unload its key
	# 5. Attempt to load the dataset specifying a keylocation of file
	# 6. Verify the key is loaded
	# 7. Verify the keylocation is the original key file
	# 8. Unload the dataset's key
	# 9. Attempt to load the dataset specifying a keylocation of prompt
	# 10. Verify the key is loaded
	# 11. Verify the keylocation is the original key file
	#

	verify_runnable "both"

	function cleanup
	{
	datasetexists $TESTPOOL/$TESTFS1 && \
	- log_must zfs destroy $TESTPOOL/$TESTFS1
	+ destroy_dataset $TESTPOOL/$TESTFS1
	}
	log_onexit cleanup

	log_assert "'zfs load-key -L' should override keylocation with provided value"

	typeset key_location="/$TESTPOOL/pkey1"

	log_must eval "echo $PASSPHRASE > $key_location"
	log_must cp $key_location /$TESTPOOL/pkey2

	log_must zfs create -o encryption=on -o keyformat=passphrase \
	-o keylocation=file://$key_location $TESTPOOL/$TESTFS1

	log_must zfs unmount $TESTPOOL/$TESTFS1
	log_must zfs unload-key $TESTPOOL/$TESTFS1

	log_must zfs load-key -L file:///$TESTPOOL/pkey2 $TESTPOOL/$TESTFS1
	log_must key_available $TESTPOOL/$TESTFS1
	log_must verify_keylocation $TESTPOOL/$TESTFS1 "file://$key_location"

	log_must zfs unload-key $TESTPOOL/$TESTFS1
	log_must eval "echo $PASSPHRASE \| zfs load-key -L prompt $TESTPOOL/$TESTFS1"
	log_must key_available $TESTPOOL/$TESTFS1
	log_must verify_keylocation $TESTPOOL/$TESTFS1 "file://$key_location"

	log_pass "'zfs load-key -L' overrides keylocation with provided value"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_load-key/zfs_load-key_noop.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_load-key/zfs_load-key_noop.ksh
	index bfce786448d9..2ee17834696f 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_load-key/zfs_load-key_noop.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_load-key/zfs_load-key_noop.ksh
	@@ -1,54 +1,54 @@
	#!/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) 2017 Datto, Inc. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/cli_root/zfs_load-key/zfs_load-key_common.kshlib

	#
	# DESCRIPTION:
	# 'zfs load-key -n' should load the key for an already loaded dataset.
	#
	# STRATEGY:
	# 1. Create an encrypted dataset
	# 2. Attempt to load the dataset's key
	# 3. Verify the key is loaded
	# 4. Attempt to load the dataset's key with an invalid key
	#

	verify_runnable "both"

	function cleanup
	{
	datasetexists $TESTPOOL/$TESTFS1 && \
	- log_must zfs destroy $TESTPOOL/$TESTFS1
	+ destroy_dataset $TESTPOOL/$TESTFS1
	}
	log_onexit cleanup

	log_assert "'zfs load-key -n' should load the key for a loaded dataset"

	log_must eval "echo $PASSPHRASE \| zfs create -o encryption=on" \
	"-o keyformat=passphrase -o keylocation=prompt $TESTPOOL/$TESTFS1"

	log_must eval "echo $PASSPHRASE \| zfs load-key -n $TESTPOOL/$TESTFS1"
	log_must key_available $TESTPOOL/$TESTFS1

	log_mustnot eval "echo $PASSPHRASE1 \| zfs load-key -n $TESTPOOL/$TESTFS1"

	log_pass "'zfs load-key -n' loads the key for a loaded dataset"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_load-key/zfs_load-key_recursive.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_load-key/zfs_load-key_recursive.ksh
	index 7385b69cf5fe..54c390f2737f 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_load-key/zfs_load-key_recursive.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_load-key/zfs_load-key_recursive.ksh
	@@ -1,66 +1,66 @@
	#!/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) 2017 Datto, Inc. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/cli_root/zfs_load-key/zfs_load-key_common.kshlib

	#
	# DESCRIPTION:
	# 'zfs load-key -r' should recursively load keys.
	#
	# STRATEGY:
	# 1. Create an encrypted dataset
	# 2. Create a child dataset as an encryption root
	# 3. Unmount all datasets and unload their keys
	# 4. Attempt to load all dataset keys
	# 5. Verify each dataset has its key loaded
	# 6. Attempt to mount each dataset
	#

	verify_runnable "both"

	function cleanup
	{
	datasetexists $TESTPOOL/$TESTFS1 && \
	- log_must zfs destroy -r $TESTPOOL/$TESTFS1
	+ destroy_dataset $TESTPOOL/$TESTFS1 -r
	}
	log_onexit cleanup

	log_assert "'zfs load-key -r' should recursively load keys"

	log_must eval "echo $PASSPHRASE1 > /$TESTPOOL/pkey"
	log_must zfs create -o encryption=on -o keyformat=passphrase \
	-o keylocation=file:///$TESTPOOL/pkey $TESTPOOL/$TESTFS1

	log_must zfs create -o keyformat=passphrase \
	-o keylocation=file:///$TESTPOOL/pkey $TESTPOOL/$TESTFS1/child

	log_must zfs unmount $TESTPOOL/$TESTFS1
	log_must zfs unload-key $TESTPOOL/$TESTFS1/child
	log_must zfs unload-key $TESTPOOL/$TESTFS1

	log_must zfs load-key -r $TESTPOOL
	log_must key_available $TESTPOOL/$TESTFS1
	log_must key_available $TESTPOOL/$TESTFS1/child

	log_must zfs mount $TESTPOOL/$TESTFS1
	log_must zfs mount $TESTPOOL/$TESTFS1/child

	log_pass "'zfs load-key -r' recursively loads keys"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_mount/zfs_mount_008_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_mount/zfs_mount_008_pos.ksh
	index 4b3bf40bc3be..6a251330f62d 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_mount/zfs_mount_008_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_mount/zfs_mount_008_pos.ksh
	@@ -1,97 +1,95 @@
	#!/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.
	#

	. $STF_SUITE/tests/functional/cli_root/zfs_mount/zfs_mount.kshlib

	#
	# DESCRIPTION:
	# 'zfs mount -O' allow the file system to be mounted over an existing
	# mount point, making the underlying file system inaccessible.
	#
	# STRATEGY:
	# 1. Create two filesystem fs & fs1, and create two test files for them.
	# 2. Unmount fs1 and set mountpoint property is identical to fs.
	# 3. Verify 'zfs mount -O' will make the underlying filesystem fs
	# inaccessible.
	#

	function cleanup
	{
	! ismounted $fs && log_must zfs mount $fs

	- if datasetexists $fs1; then
	- log_must zfs destroy $fs1
	- fi
	+ datasetexists $fs1 && destroy_dataset $fs1

	if [[ -f $testfile ]]; then
	log_must rm -f $testfile
	fi
	}

	log_assert "Verify 'zfs mount -O' will override existing mount point."
	log_onexit cleanup

	fs=$TESTPOOL/$TESTFS; fs1=$TESTPOOL/$TESTFS1

	cleanup

	# Get the original mountpoint of $fs and $fs1
	mntpnt=$(get_prop mountpoint $fs)
	log_must zfs create $fs1
	mntpnt1=$(get_prop mountpoint $fs1)

	testfile=$mntpnt/$TESTFILE0; testfile1=$mntpnt1/$TESTFILE1
	log_must mkfile 1M $testfile $testfile1

	log_must zfs unmount $fs1
	log_must zfs set mountpoint=$mntpnt $fs1
	log_must zfs mount $fs1
	log_must zfs unmount $fs1
	log_must zfs mount -O $fs1

	# Create new file in override mountpoint
	log_must mkfile 1M $mntpnt/$TESTFILE2

	# Verify the underlying file system inaccessible
	log_mustnot ls $testfile
	log_must ls $mntpnt/$TESTFILE1 $mntpnt/$TESTFILE2

	# Verify $TESTFILE2 was created in $fs1, rather than $fs
	log_must zfs unmount $fs1
	log_must zfs set mountpoint=$mntpnt1 $fs1
	log_must zfs mount $fs1
	log_must ls $testfile1 $mntpnt1/$TESTFILE2

	# Verify $TESTFILE2 was not created in $fs, and $fs is accessible again.
	log_mustnot ls $mntpnt/$TESTFILE2
	log_must ls $testfile

	log_pass "Verify 'zfs mount -O' override mount point passed."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_mount/zfs_mount_011_neg.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_mount/zfs_mount_011_neg.ksh
	index a116b4647c09..95e2bc39727a 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_mount/zfs_mount_011_neg.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_mount/zfs_mount_011_neg.ksh
	@@ -1,81 +1,80 @@
	#!/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.
	#

	. $STF_SUITE/include/libtest.shlib

	#
	# DESCRIPTION:
	# Verify that zfs mount should fail with bad parameters
	#
	# STRATEGY:
	# 1. Make an array of bad parameters
	# 2. Use zfs mount to mount the filesystem
	# 3. Verify that zfs mount returns error
	#

	verify_runnable "both"

	function cleanup
	{
	- if snapexists $TESTPOOL/$TESTFS@$TESTSNAP; then
	- log_must_busy zfs destroy $TESTPOOL/$TESTFS@$TESTSNAP
	- fi
	+ snapexists $TESTPOOL/$TESTFS@$TESTSNAP && \
	+ destroy_dataset $TESTPOOL/$TESTFS@$TESTSNAP

	if is_global_zone && datasetexists $TESTPOOL/$TESTVOL; then
	- log_must_busy zfs destroy $TESTPOOL/$TESTVOL
	+ destroy_dataset $TESTPOOL/$TESTVOL
	fi
	}

	log_assert "zfs mount fails with bad parameters"
	log_onexit cleanup

	fs=$TESTPOOL/$TESTFS
	set -A badargs "A" "-A" "-" "-x" "-?" "=" "-o *" "-a"

	for arg in "${badargs[@]}"; do
	log_mustnot eval "zfs mount $arg $fs >/dev/null 2>&1"
	done

	#verify that zfs mount fails with invalid dataset
	for opt in "-o abc" "-O"; do
	log_mustnot eval "zfs mount $opt /$fs >/dev/null 2>&1"
	done

	#verify that zfs mount fails with volume and snapshot
	log_must zfs snapshot $TESTPOOL/$TESTFS@$TESTSNAP
	log_mustnot eval "zfs mount $TESTPOOL/$TESTFS@$TESTSNAP >/dev/null 2>&1"

	if is_global_zone; then
	log_must zfs create -V 10m $TESTPOOL/$TESTVOL
	log_mustnot eval "zfs mount $TESTPOOL/$TESTVOL >/dev/null 2>&1"
	fi

	log_pass "zfs mount fails with bad parameters as expected."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_mount/zfs_mount_encrypted.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_mount/zfs_mount_encrypted.ksh
	index 9749a9b3aa8a..a95e7507b4d0 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_mount/zfs_mount_encrypted.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_mount/zfs_mount_encrypted.ksh
	@@ -1,69 +1,69 @@
	#!/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) 2017, Datto, Inc. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/cli_root/zfs_load-key/zfs_load-key_common.kshlib

	#
	# DESCRIPTION:
	# 'zfs mount -l' should accept a valid key as it mounts the filesystem.
	#
	# STRATEGY:
	# 1. Create an encrypted dataset
	# 2. Unmount and unload the dataset's key
	# 3. Verify the key is unloaded
	# 4. Attempt to mount all datasets in the pool
	# 5. Verify that no error code is produced
	# 6. Verify that the encrypted dataset is not mounted
	# 7. Attempt to load the key while mounting the dataset
	# 8. Verify the key is loaded
	# 9. Verify the dataset is mounted
	#

	verify_runnable "both"

	function cleanup
	{
	datasetexists $TESTPOOL/$TESTFS1 && \
	- log_must zfs destroy -f $TESTPOOL/$TESTFS1
	+ destroy_dataset $TESTPOOL/$TESTFS1 -f
	}

	log_onexit cleanup

	log_assert "'zfs mount -l' should properly load a valid wrapping key"

	log_must eval "echo $PASSPHRASE \| zfs create -o encryption=on" \
	"-o keyformat=passphrase $TESTPOOL/$TESTFS1"

	log_must zfs unmount $TESTPOOL/$TESTFS1
	log_must zfs unload-key $TESTPOOL/$TESTFS1
	log_must key_unavailable $TESTPOOL/$TESTFS1

	log_must zfs mount -a
	unmounted $TESTPOOL/$TESTFS1 \|\| \
	log_fail "Filesystem $TESTPOOL/$TESTFS1 is mounted"

	log_must eval "echo $PASSPHRASE \| zfs mount -l $TESTPOOL/$TESTFS1"
	log_must key_available $TESTPOOL/$TESTFS1

	mounted $TESTPOOL/$TESTFS1 \|\| \
	log_fail "Filesystem $TESTPOOL/$TESTFS1 is unmounted"

	log_pass "'zfs mount -l' properly loads a valid wrapping key"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_mount/zfs_mount_remount.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_mount/zfs_mount_remount.ksh
	index 9712c793a919..ac6103ebc7bf 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_mount/zfs_mount_remount.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_mount/zfs_mount_remount.ksh
	@@ -1,171 +1,171 @@
	#!/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 2017, loli10K <ezomori.nozomu@gmail.com>. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/cli_root/zfs_mount/zfs_mount.kshlib

	#
	# DESCRIPTION:
	# Verify remount functionality, especially on readonly objects.
	#
	# STRATEGY:
	# 1. Prepare a filesystem and a snapshot
	# 2. Verify we can (re)mount the dataset readonly/read-write
	# 3. Verify we can mount the snapshot and it's mounted readonly
	# 4. Verify we can't remount it read-write
	# 5. Verify we can remount a dataset readonly and unmount it with
	# encryption=on and sync=disabled (issue #7753)
	# 6. Re-import the pool readonly
	# 7. Verify we can't remount its filesystem read-write
	#

	verify_runnable "both"

	function cleanup
	{
	log_must_busy zpool export $TESTPOOL
	log_must zpool import $TESTPOOL
	- snapexists $TESTSNAP && log_must zfs destroy $TESTSNAP
	+ snapexists $TESTSNAP && destroy_dataset $TESTSNAP
	[[ -d $MNTPSNAP ]] && log_must rmdir $MNTPSNAP
	return 0
	}

	if is_freebsd; then
	typeset RO="-t zfs -ur"
	typeset RW="-t zfs -uw"
	else
	typeset RO="-o remount,ro"
	typeset RW="-o remount,rw"
	fi

	#
	# Verify the $filesystem is mounted readonly
	# This is preferred over "log_mustnot touch $fs" because we actually want to
	# verify the error returned is EROFS
	#
	function readonlyfs # filesystem
	{
	typeset filesystem="$1"

	file_write -o create -f $filesystem/file.dat
	ret=$?
	if [[ $ret != 30 ]]; then
	log_fail "Writing to $filesystem did not return EROFS ($ret)."
	fi
	}

	#
	# Verify $dataset is mounted with $option
	#
	function checkmount # dataset option
	{
	typeset dataset="$1"
	typeset option="$2"
	typeset options=""

	if is_freebsd; then
	options=$(mount -p \| awk -v ds="$dataset" '$1 == ds { print $4 }')
	else
	options=$(awk -v ds="$dataset" '$1 == ds { print $4 }' /proc/mounts)
	fi
	if [[ "$options" == '' ]]; then
	log_fail "Dataset $dataset is not mounted"
	elif [[ ! -z "${options##$option}" ]]; then
	log_fail "Dataset $dataset is not mounted with expected "\
	"option $option ($options)"
	else
	log_note "Dataset $dataset is mounted with option $option"
	fi
	}

	log_assert "Verify remount functionality on both filesystem and snapshots"

	log_onexit cleanup

	# 1. Prepare a filesystem and a snapshot
	TESTFS=$TESTPOOL/$TESTFS
	TESTSNAP="$TESTFS@snap"
	datasetexists $TESTFS \|\| log_must zfs create $TESTFS
	snapexists $TESTSNAP \|\| log_must zfs snapshot $TESTSNAP
	log_must zfs set readonly=off $TESTFS
	MNTPFS="$(get_prop mountpoint $TESTFS)"
	MNTPSNAP="$TESTDIR/zfs_snap_mount"
	log_must mkdir -p $MNTPSNAP

	# 2. Verify we can (re)mount the dataset readonly/read-write
	log_must touch $MNTPFS/file.dat
	checkmount $TESTFS 'rw'
	log_must mount $RO $TESTFS $MNTPFS
	readonlyfs $MNTPFS
	checkmount $TESTFS 'ro'
	log_must mount $RW $TESTFS $MNTPFS
	log_must touch $MNTPFS/file.dat
	checkmount $TESTFS 'rw'

	if is_linux; then
	# 3. Verify we can (re)mount the snapshot readonly
	log_must mount -t zfs $TESTSNAP $MNTPSNAP
	readonlyfs $MNTPSNAP
	checkmount $TESTSNAP 'ro'
	log_must mount $RO $TESTSNAP $MNTPSNAP
	readonlyfs $MNTPSNAP
	checkmount $TESTSNAP 'ro'
	log_must umount $MNTPSNAP
	fi

	# 4. Verify we can't remount a snapshot read-write
	# The "mount -o rw" command will succeed but the snapshot is mounted readonly.
	# The "mount -o remount,rw" command must fail with an explicit error.
	log_must mount -t zfs -o rw $TESTSNAP $MNTPSNAP
	readonlyfs $MNTPSNAP
	checkmount $TESTSNAP 'ro'
	log_mustnot mount $RW $TESTSNAP $MNTPSNAP
	readonlyfs $MNTPSNAP
	checkmount $TESTSNAP 'ro'
	log_must umount $MNTPSNAP

	# 5. Verify we can remount a dataset readonly and unmount it with
	# encryption=on and sync=disabled (issue #7753)
	log_must eval "echo 'password' \| zfs create -o sync=disabled \
	-o encryption=on -o keyformat=passphrase $TESTFS/crypt"
	CRYPT_MNTPFS="$(get_prop mountpoint $TESTFS/crypt)"
	log_must touch $CRYPT_MNTPFS/file.dat
	log_must mount $RO $TESTFS/crypt $CRYPT_MNTPFS
	log_must umount -f $CRYPT_MNTPFS
	zpool sync $TESTPOOL

	# 6. Re-import the pool readonly
	log_must zpool export $TESTPOOL
	log_must zpool import -o readonly=on $TESTPOOL

	# 7. Verify we can't remount its filesystem read-write
	readonlyfs $MNTPFS
	checkmount $TESTFS 'ro'
	log_mustnot mount $RW $MNTPFS
	readonlyfs $MNTPFS
	checkmount $TESTFS 'ro'

	log_pass "Both filesystem and snapshots can be remounted correctly."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_promote/zfs_promote_001_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_promote/zfs_promote_001_pos.ksh
	index 0bf7c5b6a176..dc3ffd65ed38 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_promote/zfs_promote_001_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_promote/zfs_promote_001_pos.ksh
	@@ -1,127 +1,126 @@
	#!/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) 2012, 2016 by Delphix. All rights reserved.
	#

	. $STF_SUITE/tests/functional/cli_root/zfs_promote/zfs_promote.cfg
	. $STF_SUITE/include/libtest.shlib

	#
	# DESCRIPTION:
	# 'zfs promote' can promote a clone filesystem to no longer be dependent
	# on its "origin" snapshot.
	#
	# STRATEGY:
	# 1. Create a snapshot and a clone of the snapshot
	# 2. Promote the clone filesystem
	# 3. Verify the promoted filesystem become independent
	#

	verify_runnable "both"

	function cleanup
	{
	if snapexists $csnap; then
	log_must zfs promote $fs
	fi
	- snapexists $snap && \
	- log_must zfs destroy -rR $snap
	+ snapexists $snap && destroy_dataset $snap -rR

	typeset data
	for data in $file0 $file1; do
	[[ -e $data ]] && rm -f $data
	done
	}

	function testing_verify
	{
	typeset ds=$1
	typeset ds_file=$2
	typeset snap_file=$3
	typeset c_ds=$4
	typeset c_file=$5
	typeset csnap_file=$6
	typeset origin_prop=""


	snapexists $ds@$TESTSNAP && \
	log_fail "zfs promote cannot promote $ds@$TESTSNAP."
	! snapexists $c_ds@$TESTSNAP && \
	log_fail "The $c_ds@$TESTSNAP after zfs promote doesn't exist."

	origin_prop=$(get_prop origin $ds)
	[[ "$origin_prop" != "$c_ds@$TESTSNAP" ]] && \
	log_fail "The dependency of $ds is not correct."
	origin_prop=$(get_prop origin $c_ds)
	[[ "$origin_prop" != "-" ]] && \
	log_fail "The dependency of $c_ds is not correct."

	if [[ -e $snap_file ]] \|\| [[ ! -e $csnap_file ]]; then
	log_fail "Data file $snap_file cannot be correctly promoted."
	fi
	if [[ ! -e $ds_file ]] \|\| [[ ! -e $c_file ]]; then
	log_fail "There exists data file losing after zfs promote."
	fi

	log_mustnot zfs destroy -r $c_ds
	}

	log_assert "'zfs promote' can promote a clone filesystem."
	log_onexit cleanup

	fs=$TESTPOOL/$TESTFS
	file0=$TESTDIR/$TESTFILE0
	file1=$TESTDIR/$TESTFILE1
	snap=$fs@$TESTSNAP
	snapfile=$TESTDIR/.zfs/snapshot/$TESTSNAP/$TESTFILE0
	clone=$TESTPOOL/$TESTCLONE
	cfile=/$clone/$CLONEFILE
	csnap=$clone@$TESTSNAP
	csnapfile=/$clone/.zfs/snapshot/$TESTSNAP/$TESTFILE0

	# setup for promte testing
	log_must mkfile $FILESIZE $file0
	log_must zfs snapshot $snap
	log_must mkfile $FILESIZE $file1
	log_must rm -f $file0
	log_must zfs clone $snap $clone
	log_must mkfile $FILESIZE $cfile

	log_must zfs promote $clone
	# verify the 'promote' operation
	testing_verify $fs $file1 $snapfile $clone $cfile $csnapfile

	log_note "Verify 'zfs promote' can change back the dependency relationship."
	log_must zfs promote $fs
	#verify the result
	testing_verify $clone $cfile $csnapfile $fs $file1 $snapfile

	log_pass "'zfs promote' reverses the clone parent-child dependency relationship"\
	"as expected."

	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_promote/zfs_promote_003_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_promote/zfs_promote_003_pos.ksh
	index e0d0e8457a26..7dedaf91bed6 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_promote/zfs_promote_003_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_promote/zfs_promote_003_pos.ksh
	@@ -1,134 +1,133 @@
	#!/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) 2012, 2016 by Delphix. All rights reserved.
	#

	. $STF_SUITE/tests/functional/cli_root/zfs_promote/zfs_promote.cfg
	. $STF_SUITE/include/libtest.shlib

	#
	# DESCRIPTION:
	# 'zfs promote' can deal with multi-point snapshots.
	#
	# STRATEGY:
	# 1. Create multiple snapshots and a clone to a middle point snapshot
	# 2. Promote the clone filesystem
	# 3. Verify the origin filesystem and promoted filesystem include
	# correct datasets separated by the clone point.
	#

	verify_runnable "both"

	function cleanup
	{
	if snapexists ${csnap[2]}; then
	log_must zfs promote $fs
	fi

	typeset ds
	typeset data
	for ds in ${snap[*]}; do
	- snapexists $ds && \
	- log_must zfs destroy -rR $ds
	+ snapexists $ds && destroy_dataset $ds -rR
	done
	for data in ${file[*]}; do
	[[ -e $data ]] && rm -f $data
	done

	}

	log_assert "'zfs promote' can deal with multi-point snapshots."
	log_onexit cleanup

	fs=$TESTPOOL/$TESTFS
	clone=$TESTPOOL/$TESTCLONE

	# Define some arrays here to use loop to reduce code amount

	# Array which stores the origin snapshots created in the origin filesystem
	set -A snap "${fs}@$TESTSNAP" "${fs}@$TESTSNAP1" "${fs}@$TESTSNAP2" "${fs}@$TESTSNAP3"
	# Array which stores the snapshots existing in the clone after promote operation
	set -A csnap "${clone}@$TESTSNAP" "${clone}@$TESTSNAP1" "${clone}@$TESTSNAP2" \
	"${clone}@$TESTSNAP3"
	# The data will inject into the origin filesystem
	set -A file "$TESTDIR/$TESTFILE0" "$TESTDIR/$TESTFILE1" "$TESTDIR/$TESTFILE2" \
	"$TESTDIR/$TESTFILE3"
	snapdir=$TESTDIR/.zfs/snapshot
	# The data which will exist in the snapshot after creation of snapshot
	set -A snapfile "$snapdir/$TESTSNAP/$TESTFILE0" "$snapdir/$TESTSNAP1/$TESTFILE1" \
	"$snapdir/$TESTSNAP2/$TESTFILE2" "$snapdir/$TESTSNAP3/$TESTFILE3"
	csnapdir=/$clone/.zfs/snapshot
	# The data which will exist in the snapshot of clone filesystem after promote
	set -A csnapfile "${csnapdir}/$TESTSNAP/$TESTFILE0" "${csnapdir}/$TESTSNAP1/$TESTFILE1" \
	"${csnapdir}/$TESTSNAP2/$TESTFILE2"

	# setup for promote testing
	typeset -i i=0
	while (( i < 4 )); do
	log_must mkfile $FILESIZE ${file[i]}
	(( i>0 )) && log_must rm -f ${file[((i-1))]}
	log_must zfs snapshot ${snap[i]}

	(( i = i + 1 ))
	done
	log_must zfs clone ${snap[2]} $clone
	log_must mkfile $FILESIZE /$clone/$CLONEFILE
	log_must rm -f /$clone/$TESTFILE2
	log_must zfs snapshot ${csnap[3]}

	log_must zfs promote $clone

	# verify the 'promote' operation
	for ds in ${snap[3]} ${csnap[*]}; do
	! snapexists $ds && \
	log_fail "The snapshot $ds disappear after zfs promote."
	done
	for data in ${csnapfile[*]} $TESTDIR/$TESTFILE3 /$clone/$CLONEFILE; do
	[[ ! -e $data ]] && \
	log_fail "The data file $data loses after zfs promote."
	done

	for ds in ${snap[0]} ${snap[1]} ${snap[2]}; do
	snapexists $ds && \
	log_fail "zfs promote cannot promote the snapshot $ds."
	done
	for data in ${snapfile[0]} ${snapfile[1]} ${snapfile[2]}; do
	[[ -e $data ]] && \
	log_fail "zfs promote cannot promote the data $data."
	done

	origin_prop=$(get_prop origin $fs)
	[[ "$origin_prop" != "${csnap[2]}" ]] && \
	log_fail "The dependency is not correct for $fs after zfs promote."
	origin_prop=$(get_prop origin $clone)
	[[ "$origin_prop" != "-" ]] && \
	log_fail "The dependency is not correct for $clone after zfs promote."

	log_pass "'zfs promote' deal with multi-point snapshots as expected."

	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_promote/zfs_promote_004_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_promote/zfs_promote_004_pos.ksh
	index 23b5991084f8..b8a5ab9c1707 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_promote/zfs_promote_004_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_promote/zfs_promote_004_pos.ksh
	@@ -1,140 +1,139 @@
	#!/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) 2012, 2016 by Delphix. All rights reserved.
	#

	. $STF_SUITE/tests/functional/cli_root/zfs_promote/zfs_promote.cfg
	. $STF_SUITE/include/libtest.shlib

	#
	# DESCRIPTION:
	# 'zfs promote' can deal with multi-level clones.
	#
	# STRATEGY:
	# 1. Create multiple snapshots and multi-level clones
	# 2. Promote a clone filesystem
	# 3. Verify the dataset dependency relationships are correct after promotion.
	#

	verify_runnable "both"

	function cleanup
	{
	if snapexists ${c1snap[1]}; then
	log_must zfs promote $clone
	fi

	typeset ds
	typeset data
	for ds in ${snap[*]}; do
	- snapexists $ds && \
	- log_must zfs destroy -rR $ds
	+ snapexists $ds && destroy_dataset $ds -rR
	done
	for data in ${file[*]}; do
	[[ -e $data ]] && rm -f $data
	done
	}

	log_assert "'zfs promote' can deal with multi-level clone."
	log_onexit cleanup

	fs=$TESTPOOL/$TESTFS
	clone=$TESTPOOL/$TESTCLONE
	clone1=$TESTPOOL/$TESTCLONE1

	# Define some arrays here to use loop to reduce code amount

	# Array which stores the origin snapshots created in the origin filesystem
	set -A snap "${fs}@$TESTSNAP" "${fs}@$TESTSNAP1" "${fs}@$TESTSNAP2" "${fs}@$TESTSNAP3"
	# Array which stores the snapshots existing in the first clone
	set -A csnap "${clone}@$TESTSNAP3" "${clone}@$TESTSNAP4" "${clone}@$TESTSNAP5"
	# Array which stores the snapshots existing in the second clone after promote operation
	set -A c1snap "${clone1}@$TESTSNAP3" "${clone1}@$TESTSNAP4" "${clone1}@$TESTSNAP5"
	# The data will inject into the origin filesystem
	set -A file "$TESTDIR/$TESTFILE0" "$TESTDIR/$TESTFILE1" "$TESTDIR/$TESTFILE2" \
	"$TESTDIR/$TESTFILE3"
	cdir=/$TESTPOOL/$TESTCLONE
	# The data will inject into the first clone
	set -A cfile "${cdir}/$CLONEFILE" "${cdir}/$CLONEFILE1" "${cdir}/$CLONEFILE2"
	c1snapdir=/$TESTPOOL/$TESTCLONE1/.zfs/snapshot
	# The data which will exist in the snapshot of the second clone filesystem after promote
	set -A c1snapfile "${c1snapdir}/$TESTSNAP3/$CLONEFILE" \
	"${c1snapdir}/$TESTSNAP4/$CLONEFILE1" \
	"${c1snapdir}/$TESTSNAP5/$CLONEFILE2"

	# setup for promote testing
	typeset -i i=0
	while (( i < 4 )); do
	log_must mkfile $FILESIZE ${file[i]}
	(( i>0 )) && log_must rm -f ${file[((i-1))]}
	log_must zfs snapshot ${snap[i]}

	(( i = i + 1 ))
	done
	log_must zfs clone ${snap[2]} $clone

	log_must rm -f /$clone/$TESTFILE2
	i=0
	while (( i < 3 )); do
	log_must mkfile $FILESIZE ${cfile[i]}
	(( i>0 )) && log_must rm -f ${cfile[(( i-1 ))]}
	log_must zfs snapshot ${csnap[i]}

	(( i = i + 1 ))
	done

	log_must zfs clone ${csnap[1]} $clone1
	log_must mkfile $FILESIZE /$clone1/$CLONEFILE2
	log_must rm -f /$clone1/$CLONEFILE1
	log_must zfs snapshot ${c1snap[2]}

	log_must zfs promote $clone1

	# verify the 'promote' operation
	for ds in ${snap[]} ${csnap[2]} ${c1snap[]}; do
	! snapexists $ds && \
	log_fail "The snapshot $ds disappear after zfs promote."
	done
	for data in ${c1snapfile[*]}; do
	[[ ! -e $data ]] && \
	log_fail "The data file $data loses after zfs promote."
	done

	origin_prop=$(get_prop origin $fs)
	[[ "$origin_prop" != "-" ]] && \
	log_fail "The dependency is not correct for $fs after zfs promote."
	origin_prop=$(get_prop origin $clone)
	[[ "$origin_prop" != "${c1snap[1]}" ]] && \
	log_fail "The dependency is not correct for $clone after zfs promote."
	origin_prop=$(get_prop origin $clone1)
	[[ "$origin_prop" != "${snap[2]}" ]] && \
	log_fail "The dependency is not correct for $clone1 after zfs promote."

	log_pass "'zfs promote' deal with multi-level clones as expected."

	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_promote/zfs_promote_005_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_promote/zfs_promote_005_pos.ksh
	index c669a44eb096..289ddc6713bc 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_promote/zfs_promote_005_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_promote/zfs_promote_005_pos.ksh
	@@ -1,73 +1,73 @@
	#!/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.
	#

	. $STF_SUITE/include/libtest.shlib

	#
	# DESCRIPTION:
	# The original fs was unmounted, 'zfs promote' still should succeed.
	#
	# STRATEGY:
	# 1. Create pool, fs and snapshot.
	# 2. Create clone of fs.
	# 3. Unmount fs, then verify 'zfs promote' clone still succeed.
	#

	verify_runnable "both"

	function cleanup
	{
	if datasetexists $fssnap ; then
	- datasetexists $clone && log_must zfs destroy $clone
	- log_must zfs destroy $fssnap
	+ datasetexists $clone && destroy_dataset $clone
	+ destroy_dataset $fssnap
	fi
	if datasetexists $clone ; then
	log_must zfs promote $fs
	log_must zfs destroy $clone
	log_must zfs destroy $fssnap
	fi
	}

	log_assert "The original fs was unmounted, 'zfs promote' still should succeed."
	log_onexit cleanup

	fs=$TESTPOOL/$TESTFS
	clone=$TESTPOOL/$TESTCLONE
	fssnap=$fs@fssnap

	log_must zfs snapshot $fssnap
	log_must zfs clone $fssnap $clone
	log_must zfs unmount $fs
	log_must zfs promote $clone
	log_must zfs unmount $clone
	log_must zfs promote $fs

	log_pass "Unmount original fs, 'zfs promote' passed."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_promote/zfs_promote_006_neg.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_promote/zfs_promote_006_neg.ksh
	index 286c14ac12d9..7f08f28a9379 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_promote/zfs_promote_006_neg.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_promote/zfs_promote_006_neg.ksh
	@@ -1,90 +1,86 @@
	#!/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.
	#

	. $STF_SUITE/include/libtest.shlib

	#
	# DESCRIPTION:
	# 'zfs promote' will fail with invalid arguments:
	# (1) NULL arguments
	# (2) non-existent clone
	# (3) non-clone datasets:
	# pool, fs, snapshot,volume
	# (4) too many arguments.
	# (5) invalid options
	# (6) temporary %recv datasets
	#
	# STRATEGY:
	# 1. Create an array of invalid arguments
	# 2. For each invalid argument in the array, 'zfs promote' should fail
	# 3. Verify the return code from zfs promote
	#

	verify_runnable "both"

	snap=$TESTPOOL/$TESTFS@$TESTSNAP
	clone=$TESTPOOL/$TESTCLONE
	recvfs=$TESTPOOL/recvfs
	set -A args "" \
	"$TESTPOOL/blah" \
	"$TESTPOOL" "$TESTPOOL/$TESTFS" "$snap" \
	"$TESTPOOL/$TESTVOL" "$TESTPOOL $TESTPOOL/$TESTFS" \
	"$clone $TESTPOOL/$TESTFS" "- $clone" "-? $clone" \
	"$recvfs/%recv"

	function cleanup
	{
	- if datasetexists $clone; then
	- log_must zfs destroy $clone
	- fi
	+ datasetexists $clone && destroy_dataset $clone

	- if datasetexists $recvfs; then
	- log_must zfs destroy -r $recvfs
	- fi
	+ datasetexists $recvfs && destroy_dataset $recvfs -r

	if snapexists $snap; then
	destroy_snapshot $snap
	fi
	}

	log_assert "'zfs promote' will fail with invalid arguments. "
	log_onexit cleanup

	create_recv_clone $recvfs

	typeset -i i=0
	while (( i < ${#args[*]} )); do
	log_mustnot zfs promote ${args[i]}

	(( i = i + 1 ))
	done

	log_pass "'zfs promote' fails with invalid argument as expected."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_promote/zfs_promote_007_neg.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_promote/zfs_promote_007_neg.ksh
	index 3f8ee1941dde..95db7d9e6b4e 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_promote/zfs_promote_007_neg.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_promote/zfs_promote_007_neg.ksh
	@@ -1,78 +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 2007 Sun Microsystems, Inc. All rights reserved.
	# Use is subject to license terms.
	#

	#
	# Copyright (c) 2012, 2016 by Delphix. All rights reserved.
	#

	. $STF_SUITE/tests/functional/cli_root/zfs_promote/zfs_promote.cfg
	. $STF_SUITE/include/libtest.shlib

	#
	# DESCRIPTION:
	# 'zfs promote' can deal with conflicts in the namespaces.
	#
	# STRATEGY:
	# 1. Create a snapshot and a clone of the snapshot
	# 2. Create the same name snapshot for the clone
	# 3. Promote the clone filesystem
	# 4. Verify the promote operation fail due to the name conflicts.
	#

	verify_runnable "both"

	function cleanup
	{
	- snapexists $snap && \
	- log_must zfs destroy -rR $snap
	+ snapexists $snap && destroy_dataset $snap -rR

	typeset data
	for data in $TESTDIR/$TESTFILE0 $TESTDIR/$TESTFILE1; do
	[[ -e $data ]] && rm -f $data
	done
	}

	log_assert "'zfs promote' can deal with name conflicts."
	log_onexit cleanup

	snap=$TESTPOOL/$TESTFS@$TESTSNAP
	clone=$TESTPOOL/$TESTCLONE
	clonesnap=$TESTPOOL/$TESTCLONE@$TESTSNAP

	# setup for promte testing
	log_must mkfile $FILESIZE $TESTDIR/$TESTFILE0
	log_must zfs snapshot $snap
	log_must mkfile $FILESIZE $TESTDIR/$TESTFILE1
	log_must rm -f $TESTDIR/$TESTFILE0
	log_must zfs clone $snap $clone
	log_must mkfile $FILESIZE /$clone/$CLONEFILE
	log_must zfs snapshot $clonesnap

	log_mustnot zfs promote $clone

	log_pass "'zfs promote' deals with name conflicts as expected."

	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_promote/zfs_promote_encryptionroot.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_promote/zfs_promote_encryptionroot.ksh
	index 2c7584d3541d..fd6ed7e58e3a 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_promote/zfs_promote_encryptionroot.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_promote/zfs_promote_encryptionroot.ksh
	@@ -1,93 +1,93 @@
	#!/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) 2017 Datto, Inc. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/cli_root/zfs_load-key/zfs_load-key_common.kshlib

	#
	# DESCRIPTION:
	# ZFS must promote clones of an encryption root.
	#
	# STRATEGY:
	# 1. Create an encrypted dataset
	# 2. Clone the encryption root
	# 3. Clone the clone
	# 4. Add children to each of these three datasets
	# 4. Verify the encryption root of all datasets is the origin
	# 5. Promote the clone of the clone
	# 6. Verify the encryption root of all datasets is still the origin
	# 7. Promote the dataset again, so it is now the encryption root
	# 8. Verify the encryption root of all datasets is the promoted dataset
	#

	verify_runnable "both"

	function cleanup
	{
	datasetexists $TESTPOOL/$TESTFS1 && \
	- log_must zfs destroy -Rf $TESTPOOL/$TESTFS1
	+ destroy_dataset $TESTPOOL/$TESTFS1 -Rf
	datasetexists $TESTPOOL/clone1 && \
	- log_must zfs destroy -Rf $TESTPOOL/clone1
	+ destroy_dataset $TESTPOOL/clone1 -Rf
	datasetexists $TESTPOOL/clone2 && \
	- log_must zfs destroy -Rf $TESTPOOL/clone2
	+ destroy_dataset $TESTPOOL/clone2 -Rf
	}
	log_onexit cleanup

	log_assert "ZFS must promote clones of an encryption root"

	passphrase="password"
	snaproot="$TESTPOOL/$TESTFS1@snap1"
	snapclone="$TESTPOOL/clone1@snap2"

	log_must eval "echo $passphrase \| zfs create -o encryption=on" \
	"-o keyformat=passphrase $TESTPOOL/$TESTFS1"

	log_must zfs snap $snaproot
	log_must zfs clone $snaproot $TESTPOOL/clone1
	log_must zfs snap $snapclone
	log_must zfs clone $snapclone $TESTPOOL/clone2
	log_must zfs create $TESTPOOL/$TESTFS1/child0
	log_must zfs create $TESTPOOL/clone1/child1
	log_must zfs create $TESTPOOL/clone2/child2

	log_must verify_encryption_root $TESTPOOL/$TESTFS1 $TESTPOOL/$TESTFS1
	log_must verify_encryption_root $TESTPOOL/clone1 $TESTPOOL/$TESTFS1
	log_must verify_encryption_root $TESTPOOL/clone2 $TESTPOOL/$TESTFS1
	log_must verify_encryption_root $TESTPOOL/$TESTFS1/child0 $TESTPOOL/$TESTFS1
	log_must verify_encryption_root $TESTPOOL/clone1/child1 $TESTPOOL/$TESTFS1
	log_must verify_encryption_root $TESTPOOL/clone2/child2 $TESTPOOL/$TESTFS1

	log_must zfs promote $TESTPOOL/clone2
	log_must verify_encryption_root $TESTPOOL/$TESTFS1 $TESTPOOL/$TESTFS1
	log_must verify_encryption_root $TESTPOOL/clone1 $TESTPOOL/$TESTFS1
	log_must verify_encryption_root $TESTPOOL/clone2 $TESTPOOL/$TESTFS1
	log_must verify_encryption_root $TESTPOOL/$TESTFS1/child0 $TESTPOOL/$TESTFS1
	log_must verify_encryption_root $TESTPOOL/clone1/child1 $TESTPOOL/$TESTFS1
	log_must verify_encryption_root $TESTPOOL/clone2/child2 $TESTPOOL/$TESTFS1

	log_must zfs promote $TESTPOOL/clone2
	log_must verify_encryption_root $TESTPOOL/$TESTFS1 $TESTPOOL/clone2
	log_must verify_encryption_root $TESTPOOL/clone1 $TESTPOOL/clone2
	log_must verify_encryption_root $TESTPOOL/clone2 $TESTPOOL/clone2
	log_must verify_encryption_root $TESTPOOL/$TESTFS1/child0 $TESTPOOL/clone2
	log_must verify_encryption_root $TESTPOOL/clone1/child1 $TESTPOOL/clone2
	log_must verify_encryption_root $TESTPOOL/clone2/child2 $TESTPOOL/clone2

	log_pass "ZFS promotes clones of an encryption root"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_property/zfs_written_property_001_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_property/zfs_written_property_001_pos.ksh
	index cbbacace1ec6..f31ff48099e9 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_property/zfs_written_property_001_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_property/zfs_written_property_001_pos.ksh
	@@ -1,230 +1,230 @@
	#!/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, 2017 by Delphix. All rights reserved.
	#

	#
	# DESCRIPTION
	# Verify that "zfs list" gives correct values for written and written@
	# properties for the dataset when different operations are on done on it
	#
	#
	# STRATEGY
	# 1) Create recursive datasets
	# 2) Take snapshots, write data and verify written/ written@ properties for
	# following cases
	# a) Delete data
	# b) Write Data
	# c) Clone
	# d) Delete snapshot
	# e) Recursive datasets

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/include/math.shlib

	function cleanup
	{
	for ds in $datasets; do
	- datasetexists $ds && log_must zfs destroy -R $TESTPOOL/$TESTFS1
	+ datasetexists $ds && destroy_dataset $TESTPOOL/$TESTFS1 -R
	done
	}
	function get_prop_mb
	{
	typeset prop=$1
	typeset dataset=$2
	typeset -l value=$(get_prop $prop $dataset)
	((value = value / mb_block))
	echo $value
	}

	datasets="$TESTPOOL/$TESTFS1 $TESTPOOL/$TESTFS1/$TESTFS2 \
	$TESTPOOL/$TESTFS1/$TESTFS2/$TESTFS3"

	log_assert "verify zfs written and written@ property"
	log_onexit cleanup

	typeset -l i=1
	typeset -l blocks=50
	typeset -l expected_written=0
	typeset -l expected_writtenat=0
	typeset -l written=0
	typeset -l total=0
	typeset -l snap1_size=0
	typeset -l snap2_size=0
	typeset -l snap3_size=0
	typeset -l mb_block=0
	((mb_block = 1024 * 1024))

	log_note "verify written property statistics for dataset"
	log_must zfs create -p $TESTPOOL/$TESTFS1/$TESTFS2/$TESTFS3
	for i in 1 2 3; do
	log_must zfs snapshot $TESTPOOL/$TESTFS1@snap$i
	log_must dd if=/dev/urandom of=/$TESTPOOL/$TESTFS1/testfile.$i bs=1M \
	count=$blocks
	sync_pool
	written=$(get_prop written $TESTPOOL/$TESTFS1)
	((expected_written=blocks * mb_block))
	within_percent $written $expected_written 99.5 \|\| \
	log_fail "Unexpected written value $written $expected_written"
	((total = total + blocks))
	((blocks = blocks + 50))
	done

	log_note "verify written property statistics for snapshots"
	blocks=0
	for i in 1 2 3; do
	written=$(get_prop written $TESTPOOL/$TESTFS1@snap$i)
	if [[ $blocks -eq 0 ]]; then
	# Written value for the first non-clone snapshot is
	# expected to be equal to the referenced value.
	expected_written=$( \
	get_prop referenced $TESTPOOL/$TESTFS1@snap$i)
	else
	((expected_written = blocks * mb_block))
	fi
	within_percent $written $expected_written 99.5 \|\| \
	log_fail "Unexpected written value $written $expected_written $i"
	((blocks = blocks + 50))
	done

	snap1_size=$total
	((snap2_size = total-50))
	((snap3_size = total-100))

	log_note "verify written@ for the same dataset"
	blocks=50
	for i in 1 2 3; do
	writtenat=$(get_prop written@snap$i $TESTPOOL/$TESTFS1)
	((expected_writtenat = total * mb_block))
	within_percent $writtenat $expected_writtenat 99.5 \|\| \
	log_fail "Unexpected written@ value"
	((total = total - blocks))
	((blocks = blocks + 50))
	done
	log_note "delete data"
	before_written=$(get_prop written $TESTPOOL/$TESTFS1)
	log_must rm /$TESTPOOL/$TESTFS1/testfile.3
	snap3_size=0
	sync_pool
	written=$(get_prop written $TESTPOOL/$TESTFS1)
	writtenat3=$(get_prop written@snap3 $TESTPOOL/$TESTFS1)
	[[ $written -eq $writtenat3 ]] \|\| \
	log_fail "Written and written@ don't match $written $writtenat3"
	within_percent $written $before_written 0.1 && \
	log_fail "Unexpected written value after delete $written $before_written"
	writtenat=$(get_prop written@snap1 $TESTPOOL/$TESTFS1)
	((snap1_size = snap1_size - 150))
	((expected_writtenat = snap1_size * mb_block))
	within_percent $writtenat $expected_writtenat 99.5 \|\| \
	log_fail "Unexpected written value after delete $writtenat $expected_writtenat"
	writtenat=$(get_prop written@snap2 $TESTPOOL/$TESTFS1)
	((snap2_size = snap2_size - 150))
	((expected_writtenat = snap2_size * mb_block))
	within_percent $writtenat $expected_writtenat 99.5 \|\| \
	log_fail "Unexpected written value after delete"

	log_note "write data"
	blocks=20
	log_must dd if=/dev/urandom of=/$TESTPOOL/$TESTFS1/testfile.3 bs=1M \
	count=$blocks
	sync_pool
	written=$(get_prop written $TESTPOOL/$TESTFS1)
	writtenat1=$(get_prop written@snap1 $TESTPOOL/$TESTFS1)
	writtenat2=$(get_prop written@snap2 $TESTPOOL/$TESTFS1)
	writtenat3=$(get_prop written@snap3 $TESTPOOL/$TESTFS1)
	((snap3_size = snap3_size + blocks))
	((expected_writtenat = snap3_size * mb_block))
	[[ $written -eq $writtenat3 ]] \|\| \
	log_fail "Unexpected_written value"
	within_percent $writtenat3 $expected_writtenat 99.5 \|\| \
	log_fail "Unexpected_written@ value for snap3"
	((snap2_size = snap2_size + blocks))
	((expected_writtenat = snap2_size * mb_block))
	within_percent $writtenat2 $expected_writtenat 99.5 \|\| \
	log_fail "Unexpected_written@ value for snap2"
	((snap1_size = snap1_size + blocks))
	((expected_writtenat = snap1_size * mb_block))
	within_percent $writtenat1 $expected_writtenat 99.5 \|\| \
	log_fail "Unexpected_written@ value for snap1"

	log_note "write data to a clone"
	before_clone=$(get_prop written $TESTPOOL/$TESTFS1)
	log_must zfs clone $TESTPOOL/$TESTFS1@snap1 $TESTPOOL/$TESTFS1/snap1.clone
	log_must dd if=/dev/urandom of=/$TESTPOOL/$TESTFS1/snap1.clone/testfile bs=1M \
	count=40
	after_clone=$(get_prop written $TESTPOOL/$TESTFS1)
	within_percent $before_clone $after_clone 99.5 \|\| \
	log_fail "unexpected written for clone $before_clone $after_clone"

	log_note "deleted snapshot"
	typeset -l before_written1=$(get_prop_mb written@snap1 $TESTPOOL/$TESTFS1)
	typeset -l before_written3=$(get_prop_mb written@snap3 $TESTPOOL/$TESTFS1)
	typeset -l snap_before_written2=$(get_prop_mb written $TESTPOOL/$TESTFS1@snap2)
	typeset -l snap_before_written3=$(get_prop_mb written $TESTPOOL/$TESTFS1@snap3)
	log_must zfs destroy $TESTPOOL/$TESTFS1@snap2
	log_mustnot snapexists $TESTPOOL/$TESTFS1@snap2
	sync_pool
	written1=$(get_prop_mb written@snap1 $TESTPOOL/$TESTFS1)
	written3=$(get_prop_mb written@snap3 $TESTPOOL/$TESTFS1)
	[[ $before_written1 -eq $written1 && $before_written3 -eq $written3 ]] \|\| \
	log_fail "unexpected written values $before_written1 $written1"
	typeset -l expected_written3
	((expected_written3 = snap_before_written2 + snap_before_written3))
	prev_written=$(get_prop_mb written $TESTPOOL/$TESTFS1@snap3)
	within_percent $prev_written $expected_written3 99.5 \|\| \
	log_fail "unexpected written value $prev_written $expected_written3"

	log_must zfs destroy $TESTPOOL/$TESTFS1@snap3
	log_mustnot snapexists $TESTPOOL/$TESTFS1@snap3
	written=$(get_prop written $TESTPOOL/$TESTFS1)
	writtenat1=$(get_prop written@snap1 $TESTPOOL/$TESTFS1)
	[[ $written -ne $writtenat1 ]] && \
	log_fail "Unexpected last snapshot written value"

	log_note "verify written@ property for recursive datasets"
	blocks=10
	log_must zfs snapshot -r $TESTPOOL/$TESTFS1@now
	for ds in $datasets; do
	writtenat=$(get_prop written@now $ds)
	[[ $writtenat -ne 0 ]] && \
	log_fail "Unexpected written@ value"
	log_must dd if=/dev/urandom of=/$ds/testfile bs=1M count=$blocks
	sync_pool
	writtenat=$(get_prop written@now $ds)
	((expected_writtenat = blocks * mb_block))
	within_percent $writtenat $expected_writtenat 0.1 \|\| \
	log_fail "Unexpected written value"
	((blocks = blocks + 10))
	done

	log_note "verify written@ output for recursive datasets"
	blocks=20
	for ds in $datasets; do
	log_must zfs snapshot $ds@current
	log_must dd if=/dev/urandom of=/$ds/testfile bs=1M \
	count=$blocks
	sync_pool
	done
	recursive_output=$(zfs get -p -r written@current $TESTPOOL \| \
	grep -v $TESTFS1@ \| grep -v $TESTFS2@ \| grep -v $TESTFS3@ \| \
	grep -v "VALUE" \| grep -v "-")
	expected="$((20 * mb_block))"
	for ds in $datasets; do
	writtenat=$(echo "$recursive_output" \| grep -v $ds/)
	writtenat=$(echo "$writtenat" \| grep $ds \| awk '{print $3}')
	within_percent $writtenat $expected 99.5 \|\| \
	log_fail "Unexpected written@ value on $ds"
	done

	log_pass "zfs written and written@ property fields print correct values"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_receive/zfs_receive_001_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_receive/zfs_receive_001_pos.ksh
	index f8439dcbbebd..8a6cd8c409be 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_receive/zfs_receive_001_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_receive/zfs_receive_001_pos.ksh
	@@ -1,176 +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 2008 Sun Microsystems, Inc. All rights reserved.
	# Use is subject to license terms.
	#

	#
	# Copyright (c) 2012, 2016 by Delphix. All rights reserved.
	#

	. $STF_SUITE/tests/functional/cli_root/cli_common.kshlib

	#
	# DESCRIPTION:
	# Verifying 'zfs receive [<filesystem\|snapshot>] -d <filesystem>' works.
	#
	# STRATEGY:
	# 1. Fill in fs with some data
	# 2. Create full and incremental send stream
	# 3. Receive the send stream
	# 4. Verify the restoring results.
	#

	verify_runnable "both"

	function cleanup
	{
	typeset -i i=0

	- datasetexists $rst_root && \
	- log_must zfs destroy -Rf $rst_root
	+ datasetexists $rst_root && destroy_dataset $rst_root -Rf
	while (( i < 2 )); do
	- snapexists ${orig_snap[$i]} && \
	- log_must zfs destroy -f ${orig_snap[$i]}
	+ snapexists ${orig_snap[$i]} && destroy_dataset ${orig_snap[$i]} -f
	log_must rm -f ${bkup[$i]}

	(( i = i + 1 ))
	done

	log_must rm -rf $TESTDIR1
	}

	function recreate_root
	{
	- datasetexists $rst_root && \
	- log_must zfs destroy -Rf $rst_root
	+ datasetexists $rst_root && destroy_dataset $rst_root -Rf
	if [[ -d $TESTDIR1 ]] ; then
	log_must rm -rf $TESTDIR1
	fi
	log_must zfs create $rst_root
	log_must zfs set mountpoint=$TESTDIR1 $rst_root
	}

	log_assert "Verifying 'zfs receive [<filesystem\|snapshot>] -d <filesystem>' works."
	log_onexit cleanup

	typeset datasets="$TESTPOOL/$TESTFS $TESTPOOL"
	set -A bkup "$TEST_BASE_DIR/fullbkup" "$TEST_BASE_DIR/incbkup"
	orig_sum=""
	rst_sum=""
	rst_root=$TESTPOOL/rst_ctr
	rst_fs=${rst_root}/$TESTFS

	for orig_fs in $datasets ; do
	#
	# Preparations for testing
	#
	recreate_root

	set -A orig_snap "${orig_fs}@init_snap" "${orig_fs}@inc_snap"
	typeset mntpnt=$(get_prop mountpoint ${orig_fs})
	set -A orig_data "${mntpnt}/$TESTFILE1" "${mntpnt}/$TESTFILE2"

	typeset relative_path=""
	if [[ ${orig_fs} == "/" ]]; then
	relative_path=${orig_fs#*/}
	fi

	typeset leaf_fs=${rst_root}/${relative_path}
	leaf_fs=${leaf_fs%/}
	rst_snap=${leaf_fs}@snap

	set -A rst_snap "$rst_root/$TESTFS@init_snap" "$rst_root/$TESTFS@inc_snap"
	set -A rst_snap2 "${leaf_fs}@init_snap" "${leaf_fs}@inc_snap"
	set -A rst_data "$TESTDIR1/$TESTFS/$TESTFILE1" "$TESTDIR1/$TESTFS/$TESTFILE2"
	set -A rst_data2 "$TESTDIR1/${relative_path}/$TESTFILE1" "$TESTDIR1/${relative_path}/$TESTFILE2"

	typeset -i i=0
	while (( i < ${#orig_snap[*]} )); do
	file_write -o create -f ${orig_data[$i]} -b 512 \
	-c 8 >/dev/null 2>&1
	(( $? != 0 )) && \
	log_fail "Writing data into zfs filesystem fails."
	log_must zfs snapshot ${orig_snap[$i]}
	if (( i < 1 )); then
	log_must eval "zfs send ${orig_snap[$i]} > ${bkup[$i]}"
	else
	log_must eval "zfs send -i ${orig_snap[(( i - 1 ))]} \
	${orig_snap[$i]} > ${bkup[$i]}"
	fi

	(( i = i + 1 ))
	done

	log_note "Verifying 'zfs receive <filesystem>' works."
	i=0
	while (( i < ${#bkup[*]} )); do
	if (( i > 0 )); then
	log_must zfs rollback ${rst_snap[0]}
	fi
	log_must eval "zfs receive $rst_fs < ${bkup[$i]}"
	snapexists ${rst_snap[$i]} \|\| \
	log_fail "Restoring filesystem fails. ${rst_snap[$i]} not exist"
	compare_cksum ${orig_data[$i]} ${rst_data[$i]}

	(( i = i + 1 ))
	done

	log_must zfs destroy -Rf $rst_fs

	log_note "Verifying 'zfs receive <snapshot>' works."
	i=0
	while (( i < ${#bkup[*]} )); do
	if (( i > 0 )); then
	log_must zfs rollback ${rst_snap[0]}
	fi
	log_must eval "zfs receive ${rst_snap[$i]} <${bkup[$i]}"
	snapexists ${rst_snap[$i]} \|\| \
	log_fail "Restoring filesystem fails. ${rst_snap[$i]} not exist"
	compare_cksum ${orig_data[$i]} ${rst_data[$i]}

	(( i = i + 1 ))
	done

	log_must zfs destroy -Rf $rst_fs

	log_note "Verifying 'zfs receive -d <filesystem>' works."

	i=0
	while (( i < ${#bkup[*]} )); do
	if (( i > 0 )); then
	log_must zfs rollback ${rst_snap2[0]}
	fi
	log_must eval "zfs receive -d -F $rst_root <${bkup[$i]}"
	snapexists ${rst_snap2[$i]} \|\| \
	log_fail "Restoring filesystem fails. ${rst_snap2[$i]} not exist"
	compare_cksum ${orig_data[$i]} ${rst_data2[$i]}

	(( i = i + 1 ))
	done

	cleanup
	done

	log_pass "Verifying 'zfs receive [<filesystem\|snapshot>] -d <filesystem>' succeeds."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_receive/zfs_receive_002_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_receive/zfs_receive_002_pos.ksh
	index 36af37a7576d..ba3fc49bd84c 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_receive/zfs_receive_002_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_receive/zfs_receive_002_pos.ksh
	@@ -1,108 +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 2007 Sun Microsystems, Inc. All rights reserved.
	# Use is subject to license terms.
	#

	#
	# Copyright (c) 2016 by Delphix. All rights reserved.
	#

	. $STF_SUITE/tests/functional/cli_root/cli_common.kshlib

	#
	# DESCRIPTION:
	# Verifying 'zfs receive <volume>' works.
	#
	# STRATEGY:
	# 1. Fill in volume with some data
	# 2. Create full and incremental send stream
	# 3. Restore the send stream
	# 4. Verify the restoring results.
	#

	verify_runnable "global"

	function cleanup
	{
	typeset -i i=0
	typeset ds

	while (( i < ${#orig_snap[*]} )); do
	- snapexists ${rst_snap[$i]} && \
	- log_must zfs destroy -f ${rst_snap[$i]}
	- snapexists ${orig_snap[$i]} && \
	- log_must zfs destroy -f ${orig_snap[$i]}
	+ snapexists ${rst_snap[$i]} && destroy_dataset ${rst_snap[$i]} -f
	+ snapexists ${orig_snap[$i]} && destroy_dataset ${orig_snap[$i]} -f
	[[ -e ${bkup[$i]} ]] && \
	log_must rm -rf ${bkup[$i]}

	(( i = i + 1 ))
	done

	for ds in $rst_vol $rst_root; do
	- datasetexists $ds && \
	- log_must zfs destroy -Rf $ds
	+ datasetexists $ds && destroy_dataset $ds -Rf
	done
	}

	log_assert "Verifying 'zfs receive <volume>' works."
	log_onexit cleanup

	set -A orig_snap "$TESTPOOL/$TESTVOL@init_snap" "$TESTPOOL/$TESTVOL@inc_snap"
	set -A bkup "$TEST_BASE_DIR/fullbkup" "$TEST_BASE_DIR/incbkup"
	rst_root=$TESTPOOL/rst_ctr
	rst_vol=$rst_root/$TESTVOL
	set -A rst_snap "${rst_vol}@init_snap" "${rst_vol}@inc_snap"

	#
	# Preparations for testing
	#
	log_must zfs create $rst_root
	[[ ! -d $TESTDIR1 ]] && \
	log_must mkdir -p $TESTDIR1
	log_must zfs set mountpoint=$TESTDIR1 $rst_root

	typeset -i i=0
	while (( i < ${#orig_snap[*]} )); do
	log_must zfs snapshot ${orig_snap[$i]}
	if (( i < 1 )); then
	log_must eval "zfs send ${orig_snap[$i]} > ${bkup[$i]}"
	else
	log_must eval "zfs send -i ${orig_snap[(( i - 1 ))]} \
	${orig_snap[$i]} > ${bkup[$i]}"
	fi

	(( i = i + 1 ))
	done

	i=0
	while (( i < ${#bkup[*]} )); do
	log_must eval "zfs receive $rst_vol < ${bkup[$i]}"
	! datasetexists $rst_vol \|\| ! snapexists ${rst_snap[$i]} && \
	log_fail "Restoring volume fails."

	(( i = i + 1 ))
	done

	log_pass "Verifying 'zfs receive <volume>' succeeds."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_receive/zfs_receive_003_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_receive/zfs_receive_003_pos.ksh
	index d5f6e0984df5..cce387615315 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_receive/zfs_receive_003_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_receive/zfs_receive_003_pos.ksh
	@@ -1,93 +1,93 @@
	#!/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.
	#

	. $STF_SUITE/include/libtest.shlib

	#
	# DESCRIPTION:
	# 'zfs recv -F' to force rollback.
	#
	# STRATEGY:
	# 1. Create pool and fs.
	# 2. Create some files in fs and take a snapshot1.
	# 3. Create another files in fs and take snapshot2.
	# 4. Create incremental stream from snapshot1 to snapshot2.
	# 5. fs rollback to snapshot1 and modify fs.
	# 6. Verify 'zfs recv -F' can force rollback.
	#

	verify_runnable "both"

	function cleanup
	{
	for snap in $snap2 $snap1; do
	- datasetexists $snap && log_must zfs destroy -rf $snap
	+ datasetexists $snap && destroy_dataset $snap -rf
	done
	for file in $ibackup $mntpnt/file1 $mntpnt/file2; do
	[[ -f $file ]] && log_must rm -f $file
	done
	}

	log_assert "'zfs recv -F' to force rollback."
	log_onexit cleanup

	ibackup=$TEST_BASE_DIR/ibackup.$$
	fs=$TESTPOOL/$TESTFS; snap1=$fs@snap1; snap2=$fs@snap2

	mntpnt=$(get_prop mountpoint $fs) \|\| log_fail "get_prop mountpoint $fs"
	log_must mkfile 10m $mntpnt/file1
	log_must zfs snapshot $snap1
	log_must mkfile 10m $mntpnt/file2
	log_must zfs snapshot $snap2

	log_must eval "zfs send -i $snap1 $snap2 > $ibackup"

	log_note "Verify 'zfs receive' succeed, if filesystem was not modified."
	log_must zfs rollback -r $snap1
	log_must eval "zfs receive $fs < $ibackup"
	if [[ ! -f $mntpnt/file1 \|\| ! -f $mntpnt/file2 ]]; then
	log_fail "'zfs receive' failed."
	fi

	log_note "Verify 'zfs receive' failed if filesystem was modified."
	log_must zfs rollback -r $snap1
	log_must rm -rf $mntpnt/file1
	log_mustnot eval "zfs receive $fs < $ibackup"

	# Verify 'zfs receive -F' to force rollback whatever filesystem was modified.
	log_must zfs rollback -r $snap1
	log_must rm -rf $mntpnt/file1
	log_must eval "zfs receive -F $fs < $ibackup"
	if [[ ! -f $mntpnt/file1 \|\| ! -f $mntpnt/file2 ]]; then
	log_fail "'zfs receive -F' failed."
	fi

	log_pass "'zfs recv -F' to force rollback passed."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_receive/zfs_receive_004_neg.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_receive/zfs_receive_004_neg.ksh
	index 56f536225d74..7c115ee33b96 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_receive/zfs_receive_004_neg.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_receive/zfs_receive_004_neg.ksh
	@@ -1,110 +1,109 @@
	#!/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) 2012, 2016 by Delphix. All rights reserved.
	#

	. $STF_SUITE/tests/functional/cli_root/cli_common.kshlib

	#
	# DESCRIPTION:
	# Verify 'zfs receive' fails with malformed parameters.
	#
	# STRATEGY:
	# 1. Define malformed parameters array
	# 2. Feed the malformed parameters to 'zfs receive'
	# 3. Verify the command should be failed
	#

	verify_runnable "both"

	function cleanup
	{
	typeset snap
	typeset bkup

	for snap in $init_snap $inc_snap $init_topsnap $inc_topsnap ; do
	- snapexists $snap && \
	- log_must zfs destroy -Rf $snap
	+ snapexists $snap && destroy_dataset $snap -Rf
	done

	for bkup in $full_bkup $inc_bkup $full_topbkup $inc_topbkup; do
	[[ -e $bkup ]] && \
	log_must rm -f $bkup
	done
	}

	log_assert "Verify that invalid parameters to 'zfs receive' are caught."
	log_onexit cleanup

	init_snap=$TESTPOOL/$TESTFS@initsnap
	inc_snap=$TESTPOOL/$TESTFS@incsnap
	full_bkup=$TEST_BASE_DIR/full_bkup.$$
	inc_bkup=$TEST_BASE_DIR/inc_bkup.$$

	init_topsnap=$TESTPOOL@initsnap
	inc_topsnap=$TESTPOOL@incsnap
	full_topbkup=$TEST_BASE_DIR/full_topbkup.$$
	inc_topbkup=$TEST_BASE_DIR/inc_topbkup.$$

	log_must zfs snapshot $init_topsnap
	log_must eval "zfs send $init_topsnap > $full_topbkup"
	log_must touch /$TESTPOOL/foo

	log_must zfs snapshot $inc_topsnap
	log_must eval "zfs send -i $init_topsnap $inc_topsnap > $inc_topbkup"
	log_must touch /$TESTPOOL/bar

	log_must zfs snapshot $init_snap
	log_must eval "zfs send $init_snap > $full_bkup"
	log_must touch /$TESTDIR/foo

	log_must zfs snapshot $inc_snap
	log_must eval "zfs send -i $init_snap $inc_snap > $inc_bkup"
	log_must touch /$TESTDIR/bar

	sync

	set -A badargs \
	"" "nonexistent-snap" "blah@blah" "-d" "-d nonexistent-dataset" \
	"$TESTPOOL1" "$TESTPOOL/fs@" "$TESTPOOL/fs@@mysnap" \
	"$TESTPOOL/fs@@" "$TESTPOOL/fs/@mysnap" "$TESTPOOL/fs@/mysnap" \
	"$TESTPOOL/nonexistent-fs/nonexistent-fs" "-d $TESTPOOL/nonexistent-fs" \
	"-d $TESTPOOL/$TESTFS/nonexistent-fs"

	typeset -i i=0
	while (( i < ${#badargs[*]} ))
	do
	for bkup in $full_bkup $inc_bkup $full_topbkup $inc_topbkup ; do
	log_mustnot eval "zfs receive ${badargs[i]} < $bkup"
	done

	(( i = i + 1 ))
	done

	log_pass "Invalid parameters to 'zfs receive' are caught as expected."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_receive/zfs_receive_005_neg.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_receive/zfs_receive_005_neg.ksh
	index ce89c6835775..d8c71f2c2877 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_receive/zfs_receive_005_neg.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_receive/zfs_receive_005_neg.ksh
	@@ -1,99 +1,97 @@
	#!/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.
	#

	. $STF_SUITE/tests/functional/cli_root/cli_common.kshlib

	#
	# DESCRIPTION:
	# Verify 'zfs receive' fails with unsupported scenarios.
	# including:
	# (1) Invalid send streams;
	# (2) The received incremental send doesn't match the filesystem
	# latest status.
	#
	# STRATEGY:
	# 1. Preparation for unsupported scenarios
	# 2. Execute 'zfs receive'
	# 3. Verify the results are failed
	#

	verify_runnable "both"

	function cleanup
	{
	typeset snap
	typeset bkup

	for snap in $init_snap $inc_snap; do
	- snapexists $snap && \
	- log_must zfs destroy -f $snap
	+ snapexists $snap && destroy_dataset $snap -f
	done

	- datasetexists $rst_root && \
	- log_must zfs destroy -Rf $rst_root
	+ datasetexists $rst_root && destroy_dataset $rst_root -Rf

	for bkup in $full_bkup $inc_bkup; do
	[[ -e $bkup ]] && \
	log_must rm -f $bkup
	done
	}

	log_assert "Verify 'zfs receive' fails with unsupported scenarios."
	log_onexit cleanup

	init_snap=$TESTPOOL/$TESTFS@initsnap
	inc_snap=$TESTPOOL/$TESTFS@incsnap
	rst_root=$TESTPOOL/rst_ctr
	rst_init_snap=$rst_root/$TESTFS@init_snap
	rst_inc_snap=$rst_root/$TESTFS@inc_snap
	full_bkup=$TEST_BASE_DIR/full_bkup.$$
	inc_bkup=$TEST_BASE_DIR/inc_bkup.$$

	log_must zfs create $rst_root
	log_must zfs snapshot $init_snap
	log_must eval "zfs send $init_snap > $full_bkup"

	log_note "'zfs receive' fails with invalid send streams."
	log_mustnot eval "cat </dev/zero \| zfs receive $rst_init_snap"
	log_mustnot eval "cat </dev/zero \| zfs receive -d $rst_root"

	log_must eval "zfs receive $rst_init_snap < $full_bkup"

	log_note "Unmatched send stream with restoring filesystem" \
	" cannot be received."
	log_must zfs snapshot $inc_snap
	log_must eval "zfs send -i $init_snap $inc_snap > $inc_bkup"
	#make changes on the restoring filesystem
	log_must touch $ZFSROOT/$rst_root/$TESTFS/tmpfile
	log_mustnot eval "zfs receive $rst_inc_snap < $inc_bkup"
	log_mustnot eval "zfs receive -d $rst_root < $inc_bkup"

	log_pass "Unsupported scenarios to 'zfs receive' fail as expected."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_receive/zfs_receive_006_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_receive/zfs_receive_006_pos.ksh
	index 7338fd2b9fb2..79f34bd3ff8c 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_receive/zfs_receive_006_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_receive/zfs_receive_006_pos.ksh
	@@ -1,108 +1,108 @@
	#!/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.
	#

	. $STF_SUITE/include/libtest.shlib

	#
	# DESCRIPTION:
	# 'zfs recv -d <fs>' should create ancestor filesystem if it does not
	# exist and it should not fail if it exists
	#
	# STRATEGY:
	# 1. Create pool and fs.
	# 2. Create some files in fs and take snapshots.
	# 3. Keep the stream and restore the stream to the pool
	# 4. Verify receiving the stream succeeds, and the ancestor filesystem
	# is created if it did not exist
	# 5. Verify receiving the stream still succeeds when ancestor filesystem
	# exists
	#

	verify_runnable "both"

	function cleanup
	{
	for snap in $snap2 $snap1; do
	- datasetexists $snap && log_must zfs destroy -rf $snap
	+ datasetexists $snap && destroy_dataset $snap -rf
	done
	for file in $fbackup1 $fbackup2 $mntpnt/file1 $mntpnt/file2; do
	[[ -f $file ]] && log_must rm -f $file
	done

	if is_global_zone; then
	datasetexists $TESTPOOL/$TESTFS/$TESTFS1 && \
	- log_must zfs destroy -rf $TESTPOOL/$TESTFS/$TESTFS1
	+ destroy_dataset $TESTPOOL/$TESTFS/$TESTFS1 -rf
	else
	datasetexists $TESTPOOL/${ZONE_CTR}0 && \
	- log_must zfs destroy -rf $TESTPOOL/${ZONE_CTR}0
	+ destroy_dataset $TESTPOOL/${ZONE_CTR}0 -rf
	fi

	}

	log_assert "'zfs recv -d <fs>' should succeed no matter ancestor filesystem \
	exists."
	log_onexit cleanup

	ancestor_fs=$TESTPOOL/$TESTFS
	fs=$TESTPOOL/$TESTFS/$TESTFS1
	snap1=$fs@snap1
	snap2=$fs@snap2
	fbackup1=$TEST_BASE_DIR/fbackup1.$$
	fbackup2=$TEST_BASE_DIR/fbackup2.$$

	datasetexists $ancestor_fs \|\| \
	log_must zfs create $ancestor_fs
	log_must zfs create $fs

	mntpnt=$(get_prop mountpoint $fs) \|\| log_fail "get_prop mountpoint $fs"
	log_must mkfile 10m $mntpnt/file1
	log_must zfs snapshot $snap1
	log_must mkfile 10m $mntpnt/file2
	log_must zfs snapshot $snap2

	log_must eval "zfs send $snap1 > $fbackup1"
	log_must eval "zfs send $snap2 > $fbackup2"

	log_note "Verify 'zfs receive -d' succeed and create ancestor filesystem \
	if it did not exist. "
	log_must zfs destroy -rf $ancestor_fs
	log_must eval "zfs receive -d $TESTPOOL < $fbackup1"
	is_global_zone \|\| ancestor_fs=$TESTPOOL/${ZONE_CTR}0/$TESTFS
	datasetexists $ancestor_fs \|\| \
	log_fail "ancestor filesystem is not created"

	log_note "Verify 'zfs receive -d' still succeed if ancestor filesystem exists"
	is_global_zone \|\| fs=$TESTPOOL/${ZONE_CTR}0/$TESTFS/$TESTFS1
	log_must zfs destroy -rf $fs
	log_must eval "zfs receive -d $TESTPOOL < $fbackup2"

	log_pass "'zfs recv -d <fs>' should succeed no matter ancestor filesystem \
	exists."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_receive/zfs_receive_007_neg.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_receive/zfs_receive_007_neg.ksh
	index 57454dcbc6f2..fbf0654e4f23 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_receive/zfs_receive_007_neg.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_receive/zfs_receive_007_neg.ksh
	@@ -1,84 +1,84 @@
	#!/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.
	#

	. $STF_SUITE/include/libtest.shlib

	#
	# DESCRIPTION:
	# 'zfs recv -F' should fail if the incremental stream does not match
	#
	# STRATEGY:
	# 1. Create pool and fs.
	# 2. Create some files in fs and take snapshots.
	# 3. Keep the incremental stream and restore the stream to the pool
	# 4. Verify receiving the stream fails
	#

	verify_runnable "both"

	function cleanup
	{
	for snap in $snap2 $snap1; do
	- datasetexists $snap && log_must zfs destroy -rf $snap
	+ datasetexists $snap && destroy_dataset $snap -rf
	done
	for file in $ibackup $mntpnt/file1 $mntpnt/file2; do
	[[ -f $file ]] && log_must rm -f $file
	done
	}

	log_assert "'zfs recv -F' should fail if the incremental stream does not match"
	log_onexit cleanup

	fs=$TESTPOOL/$TESTFS
	snap1=$fs@snap1
	snap2=$fs@snap2
	ibackup=$TEST_BASE_DIR/ibackup.$$

	datasetexists $fs \|\| log_must zfs create $fs

	mntpnt=$(get_prop mountpoint $fs) \|\| log_fail "get_prop mountpoint $fs"
	log_must mkfile 10m $mntpnt/file1
	log_must zfs snapshot $snap1
	log_must mkfile 10m $mntpnt/file2
	log_must zfs snapshot $snap2

	log_must eval "zfs send -i $snap1 $snap2 > $ibackup"

	log_must zfs destroy $snap1
	log_must zfs destroy $snap2
	log_mustnot eval "zfs receive -F $fs < $ibackup"

	log_must mkfile 20m $mntpnt/file1
	log_must rm -rf $mntpnt/file2
	log_must zfs snapshot $snap1
	log_mustnot eval "zfs receive -F $snap2 < $ibackup"

	log_pass "'zfs recv -F' should fail if the incremental stream does not match"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_receive/zfs_receive_008_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_receive/zfs_receive_008_pos.ksh
	index 1729b59b2bfd..dc4892b5d50e 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_receive/zfs_receive_008_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_receive/zfs_receive_008_pos.ksh
	@@ -1,148 +1,144 @@
	#!/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) 2016 by Delphix. All rights reserved.
	#

	. $STF_SUITE/tests/functional/cli_root/cli_common.kshlib

	#
	# DESCRIPTION:
	# Verifying 'zfs receive -vn [<filesystem\|snapshot>]
	# and zfs receive -vn -d <filesystem>'
	#
	# STRATEGY:
	# 1. Fill in fs with some data
	# 2. Create full and incremental send stream
	# 3. run zfs receive with -v option
	# 3. Dryrun zfs receive with -vn option
	# 3. Dryrun zfs receive with -vn -d option
	# 4. Verify receive output and result
	#
	function cleanup
	{
	for dset in $rst_snap $rst_fs $orig_snap; do
	- if datasetexists $dset; then
	- log_must zfs destroy -fr $dset
	- fi
	+ datasetexists $dset && destroy_dataset $dset -fr
	done

	for file in $fbackup $mnt_file $tmp_out; do
	if [[ -f $file ]]; then
	log_must rm -f $file
	fi
	done

	if datasetexists $TESTPOOL/$TESTFS; then
	- log_must zfs destroy -Rf $TESTPOOL/$TESTFS
	+ destroy_dataset $TESTPOOL/$TESTFS -Rf
	log_must zfs create $TESTPOOL/$TESTFS
	log_must zfs set mountpoint=$TESTDIR $TESTPOOL/$TESTFS
	fi
	}

	verify_runnable "both"
	log_assert "Verifying 'zfs receive -vn [<filesystem\|snapshot>] " \
	"and zfs receive -vn -d <filesystem>'"

	log_onexit cleanup

	typeset datasets="$TESTPOOL/$TESTFS $TESTPOOL"
	typeset rst_fs=$TESTPOOL/$TESTFS/$TESTFS
	typeset fbackup=$TEST_BASE_DIR/fbackup.$$
	typeset tmp_out=$TEST_BASE_DIR/tmpout.$$

	for orig_fs in $datasets ; do
	typeset rst_snap=$rst_fs@snap
	typeset orig_snap=$orig_fs@snap
	typeset verb_msg="receiving full stream of ${orig_snap} into ${rst_snap}"
	typeset dryrun_msg="would receive full stream of ${orig_snap} into ${rst_snap}"

	if ! datasetexists $orig_fs; then
	log_must zfs create $orig_fs
	fi

	typeset mntpnt
	mntpnt=$(get_prop mountpoint $orig_fs)
	if [[ $? -ne 0 ]] ; then
	log_fail "get_prop mountpoint $orig_fs failed"
	fi

	typeset mnt_file=$mntpnt/file1

	log_must mkfile 100m $mnt_file
	log_must zfs snapshot $orig_snap
	log_must eval "zfs send $orig_snap > $fbackup"

	for opt in "-v" "-vn"; do
	- if datasetexists $rst_fs; then
	- log_must zfs destroy -fr $rst_fs
	- fi
	+ datasetexists $rst_fs && destroy_dataset $rst_fs -fr
	log_note "Check ZFS receive $opt [<filesystem\|snapshot>]"
	log_must eval "zfs receive $opt $rst_fs < $fbackup > $tmp_out 2>&1"
	if [[ $opt == "-v" ]]; then
	log_must eval "grep \"$verb_msg\" $tmp_out >/dev/null 2>&1"
	if ! datasetexists $rst_snap; then
	log_fail "dataset was not received, even though the"\
	" -v flag was used."
	fi
	else
	log_must eval "grep \"$dryrun_msg\" $tmp_out >/dev/null 2>&1"
	if datasetexists $rst_snap; then
	log_fail "dataset was received, even though the -nv"\
	" flag was used."
	fi
	fi
	done

	log_note "Check ZFS receive -vn -d <filesystem>"
	if ! datasetexists $rst_fs; then
	log_must zfs create $rst_fs
	fi
	log_must eval "zfs receive -vn -d -F $rst_fs <$fbackup >$tmp_out 2>&1"
	typeset relative_path=""
	if [[ ${orig_fs} == "/" ]]; then
	relative_path=${orig_fs#*/}
	fi

	typeset leaf_fs=${rst_fs}/${relative_path}
	leaf_fs=${leaf_fs%/}
	rst_snap=${leaf_fs}@snap
	dryrun_msg="would receive full stream of ${orig_snap} into ${rst_snap}"

	log_must eval "grep \"$dryrun_msg\" $tmp_out > /dev/null 2>&1"

	if datasetexists $rst_snap; then
	log_fail "dataset $rst_snap should not existed."
	fi
	log_must zfs destroy -Rf $rst_fs

	cleanup
	done

	log_pass "zfs receive -vn [<filesystem\|snapshot>] and " \
	"zfs receive -vn -d <filesystem>' succeed."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_receive/zfs_receive_009_neg.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_receive/zfs_receive_009_neg.ksh
	index d028acafada0..37fe515e23f7 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_receive/zfs_receive_009_neg.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_receive/zfs_receive_009_neg.ksh
	@@ -1,118 +1,115 @@
	#!/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.
	#

	. $STF_SUITE/tests/functional/cli_root/cli_common.kshlib

	#
	# DESCRIPTION:
	# Verify 'zfs receive' fails with bad options, missing argument or too many
	# arguments.
	#
	# STRATEGY:
	# 1. Set a array of illegal arguments
	# 2. Execute 'zfs receive' with illegal arguments
	# 3. Verify the command should be failed
	#

	verify_runnable "both"

	function cleanup
	{
	typeset ds

	- if snapexists $snap; then
	- log_must zfs destroy $snap
	- fi
	+ snapexists $snap && destroy_dataset $snap
	+
	for ds in $ctr1 $ctr2 $fs1; do
	- if datasetexists $ds; then
	- log_must zfs destroy -rf $ds
	- fi
	+ datasetexists $ds && destroy_dataset $ds -rf
	done
	if [[ -d $TESTDIR2 ]]; then
	rm -rf $TESTDIR2
	fi
	}

	log_assert "Verify 'zfs receive' fails with bad option, missing or too many arguments"
	log_onexit cleanup

	set -A badopts "v" "n" "F" "d" "-V" "-N" "-f" "-D" "-VNfD" "-vNFd" "-vnFD" "-dVnF" \
	"-vvvNfd" "-blah" "-12345" "-?" "-*" "-%"
	set -A validopts "" "-v" "-n" "-F" "-vn" "-nF" "-vnF" "-vd" "-nd" "-Fd" "-vnFd"

	ctr1=$TESTPOOL/$TESTCTR1
	ctr2=$TESTPOOL/$TESTCTR2
	fs1=$TESTPOOL/$TESTFS1
	fs2=$TESTPOOL/$TESTFS2
	fs3=$TESTPOOL/$TESTFS3
	snap=$TESTPOOL/$TESTFS@$TESTSNAP
	bkup=$TESTDIR2/bkup.$$

	# Preparations for negative testing
	for ctr in $ctr1 $ctr2; do
	log_must zfs create $ctr
	done
	if [[ -d $TESTDIR2 ]]; then
	rm -rf $TESTDIR2
	fi
	log_must zfs create -o mountpoint=$TESTDIR2 $fs1
	log_must zfs snapshot $snap
	log_must eval "zfs send $snap > $bkup"

	#Testing zfs receive fails with input from terminal
	log_mustnot eval "zfs recv $fs3 </dev/console"

	# Testing with missing argument and too many arguments
	typeset -i i=0
	while (( i < ${#validopts[*]} )); do
	log_mustnot eval "zfs recv < $bkup"

	echo ${validopts[i]} \| grep "d" >/dev/null 2>&1
	if (( $? != 0 )); then
	log_mustnot eval "zfs recv ${validopts[i]} $fs2 $fs3 < $bkup"
	else
	log_mustnot eval "zfs recv ${validopts[i]} $ctr1 $ctr2 < $bkup"
	fi

	(( i += 1 ))
	done

	# Testing with bad options
	i=0
	while (( i < ${#badopts[*]} ))
	do
	log_mustnot eval "zfs recv ${badopts[i]} $ctr1 < $bkup"
	log_mustnot eval "zfs recv ${badopts[i]} $fs2 < $bkup"

	(( i = i + 1 ))
	done

	log_pass "'zfs receive' as expected with bad options, missing or too many arguments."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_receive/zfs_receive_013_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_receive/zfs_receive_013_pos.ksh
	index be8f49809d47..e1e93e9d2a3b 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_receive/zfs_receive_013_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_receive/zfs_receive_013_pos.ksh
	@@ -1,75 +1,75 @@
	#!/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/tests/functional/cli_root/cli_common.kshlib

	#
	# DESCRIPTION:
	# Verifying 'zfs receive' works correctly on deduplicated streams
	#
	# STRATEGY:
	# 1. Create some snapshots with duplicated data
	# 2. Send a deduplicated stream of the last snapshot
	# 3. Attempt to receive the deduplicated stream
	#

	src_fs=$TESTPOOL/drecvsrc
	temppool=recvtank
	dst_fs=$temppool/drecvdest
	streamfile=$TEST_BASE_DIR/drecvstream.$$
	tpoolfile=$TEST_BASE_DIR/temptank.$$

	function cleanup
	{
	for fs in $src_fs $dst_fs; do
	- datasetexists $fs && log_must zfs destroy -rf $fs
	+ datasetexists $fs && log_must destroy_dataset $fs -rf
	done
	zpool destroy $temppool
	[[ -f $streamfile ]] && log_must rm -f $streamfile
	[[ -f $tpoolfile ]] && log_must rm -f $tpoolfile
	}

	log_assert "Verifying 'zfs receive' works correctly on deduplicated streams"
	log_onexit cleanup

	truncate -s 100M $tpoolfile
	log_must zpool create $temppool $tpoolfile
	log_must zfs create $src_fs
	src_mnt=$(get_prop mountpoint $src_fs) \|\| log_fail "get_prop mountpoint $src_fs"

	echo blah > $src_mnt/blah
	zfs snapshot $src_fs@base

	echo grumble > $src_mnt/grumble
	echo blah > $src_mnt/blah2
	zfs snapshot $src_fs@snap2

	echo grumble > $src_mnt/mumble
	echo blah > $src_mnt/blah3
	zfs snapshot $src_fs@snap3

	log_must eval "zfs send -D -R $src_fs@snap3 > $streamfile"
	log_must eval "zfs receive -v $dst_fs < $streamfile"
	log_must zfs destroy -r $dst_fs
	log_must eval "zstream redup $streamfile \| zfs receive -v $dst_fs"

	cleanup

	log_pass "Verifying 'zfs receive' works correctly on deduplicated streams"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_receive/zfs_receive_from_encrypted.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_receive/zfs_receive_from_encrypted.ksh
	index a1d094bdb4ba..891432685287 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_receive/zfs_receive_from_encrypted.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_receive/zfs_receive_from_encrypted.ksh
	@@ -1,83 +1,83 @@
	#!/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) 2017 Datto, Inc. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib

	#
	# DESCRIPTION:
	# ZFS should receive an unencrypted stream from an encrypted dataset
	#
	# STRATEGY:
	# 1. Create an unencrypted dataset
	# 2. Create an encrypted dataset
	# 3. Create and checksum a file on the encrypted dataset
	# 4. Snapshot the encrypted dataset
	# 5. Attempt to receive the snapshot into an unencrypted child
	# 6. Verify encryption is not enabled
	# 7. Verify the checksum of the file is the same as the original
	# 8. Attempt to receive the snapshot into an encrypted child
	# 9. Verify the checksum of the file is the same as the original
	#

	verify_runnable "both"

	function cleanup
	{
	datasetexists $TESTPOOL/$TESTFS1 && \
	- log_must zfs destroy -r $TESTPOOL/$TESTFS1
	+ destroy_dataset $TESTPOOL/$TESTFS1 -r

	datasetexists $TESTPOOL/$TESTFS2 && \
	- log_must zfs destroy -r $TESTPOOL/$TESTFS2
	+ destroy_dataset $TESTPOOL/$TESTFS2 -r
	}

	log_onexit cleanup

	log_assert "ZFS should receive an unencrypted stream from an encrypted dataset"

	typeset passphrase="password"
	typeset snap="$TESTPOOL/$TESTFS2@snap"

	log_must zfs create $TESTPOOL/$TESTFS1
	log_must eval "echo $passphrase \| zfs create -o encryption=on" \
	"-o keyformat=passphrase $TESTPOOL/$TESTFS2"

	log_must mkfile 1M /$TESTPOOL/$TESTFS2/$TESTFILE0
	typeset checksum=$(md5digest /$TESTPOOL/$TESTFS2/$TESTFILE0)

	log_must zfs snapshot $snap

	log_note "Verify ZFS can receive into an unencrypted child"
	log_must eval "zfs send $snap \| zfs receive $TESTPOOL/$TESTFS1/c1"

	crypt=$(get_prop encryption $TESTPOOL/$TESTFS1/c1)
	[[ "$crypt" == "off" ]] \|\| log_fail "Received unencrypted stream as encrypted"

	typeset cksum1=$(md5digest /$TESTPOOL/$TESTFS1/c1/$TESTFILE0)
	[[ "$cksum1" == "$checksum" ]] \|\| \
	log_fail "Checksums differ ($cksum1 != $checksum)"

	log_note "Verify ZFS can receive into an encrypted child"
	log_must eval "zfs send $snap \| zfs receive $TESTPOOL/$TESTFS2/c1"

	typeset cksum2=$(md5digest /$TESTPOOL/$TESTFS2/c1/$TESTFILE0)
	[[ "$cksum2" == "$checksum" ]] \|\| \
	log_fail "Checksums differ ($cksum2 != $checksum)"

	log_pass "ZFS can receive an unencrypted stream from an encrypted dataset"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_receive/zfs_receive_from_zstd.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_receive/zfs_receive_from_zstd.ksh
	index 14a175912bb2..72eebb4f9321 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_receive/zfs_receive_from_zstd.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_receive/zfs_receive_from_zstd.ksh
	@@ -1,112 +1,112 @@
	#!/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 The FreeBSD Foundation [1]
	#
	# [1] Portions of this software were developed by Allan Jude
	# under sponsorship from the FreeBSD Foundation.

	. $STF_SUITE/include/libtest.shlib

	#
	# DESCRIPTION:
	# ZFS should receive a ZSTD compressed block and be able to determine the level
	#
	# STRATEGY:
	# 1. Create a ZSTD compressed dataset (random level)
	# 2. Create and checksum a file on the compressed dataset
	# 3. Snapshot the compressed dataset
	# 4. Attempt to receive the snapshot into a new dataset
	# 5. Verify the checksum of the file is the same as the original
	# 6. Verify the compression level is correctly stored
	#

	verify_runnable "both"

	function cleanup
	{
	datasetexists $TESTPOOL/$TESTFS1 && \
	- log_must zfs destroy -r $TESTPOOL/$TESTFS1
	+ destroy_dataset $TESTPOOL/$TESTFS1 -r

	datasetexists $TESTPOOL/$TESTFS2 && \
	- log_must zfs destroy -r $TESTPOOL/$TESTFS2
	+ destroy_dataset $TESTPOOL/$TESTFS2 -r
	}

	log_onexit cleanup

	log_assert "ZFS should track compression level when receiving a ZSTD stream"

	typeset src_data="$STF_SUITE/tests/functional/cli_root/zfs_receive/zstd_test_data.txt"
	typeset snap="$TESTPOOL/$TESTFS1@snap"

	random_level=$((RANDOM%19 + 1))
	log_note "Randomly selected ZSTD level: $random_level"

	log_must zfs create -o compress=zstd-$random_level $TESTPOOL/$TESTFS1
	# Make a 5kb compressible file
	log_must cat $src_data $src_data $src_data $src_data $src_data \
	> /$TESTPOOL/$TESTFS1/$TESTFILE0
	typeset checksum=$(md5digest /$TESTPOOL/$TESTFS1/$TESTFILE0)

	log_must zfs snapshot $snap

	# get object number of file
	listing=$(ls -i /$TESTPOOL/$TESTFS1/$TESTFILE0)
	set -A array $listing
	obj=${array[0]}
	log_note "file /$TESTPOOL/$TESTFS1/$TESTFILE0 has object number $obj"

	output=$(zdb -Zddddddbbbbbb $TESTPOOL/$TESTFS1 $obj 2> /dev/null \
	\|grep -m 1 "L0 DVA" \|head -n1)
	dva=$(sed -Ene 's/^.+DVA\[0\]=<([^>]+)>.*$/\1/p' <<< "$output")
	log_note "block 0 of /$TESTPOOL/$TESTFS1/$TESTFILE0 has a DVA of $dva"

	zstd_str=$(sed -Ene 's/^.+ ZSTD:size=([^:]+):version=([^:]+):level=([^:]+):.*$/\1:\2:\3/p' <<< "$output")
	zstd_size1=$(echo "$zstd_str" \|awk '{split($0,array,":")} END{print array[1]}')
	zstd_version1=$(echo "$zstd_str" \|awk '{split($0,array,":")} END{print array[2]}')
	zstd_level1=$(echo "$zstd_str" \|awk '{split($0,array,":")} END{print array[3]}')
	log_note "ZSTD src: size=$zstd_size1 version=$zstd_version1 level=$zstd_level1"

	log_note "Verify ZFS can receive the ZSTD compressed stream"
	log_must eval "zfs send -ec $snap \| zfs receive $TESTPOOL/$TESTFS2"

	typeset cksum1=$(md5digest /$TESTPOOL/$TESTFS2/$TESTFILE0)
	[[ "$cksum1" == "$checksum" ]] \|\| \
	log_fail "Checksums differ ($cksum1 != $checksum)"

	# get object number of file
	listing=$(ls -i /$TESTPOOL/$TESTFS2/$TESTFILE0)
	set -A array $listing
	obj=${array[0]}
	log_note "file /$TESTPOOL/$TESTFS2/$TESTFILE0 has object number $obj"

	output=$(zdb -Zddddddbbbbbb $TESTPOOL/$TESTFS2 $obj 2> /dev/null \
	\|grep -m 1 "L0 DVA" \|head -n1)
	dva=$(sed -Ene 's/^.+DVA\[0\]=<([^>]+)>.*$/\1/p' <<< "$output")
	log_note "block 0 of /$TESTPOOL/$TESTFS2/$TESTFILE0 has a DVA of $dva"

	zstd_str=$(sed -Ene 's/^.+ ZSTD:size=([^:]+):version=([^:]+):level=([^:]+):.*$/\1:\2:\3/p' <<< "$output")
	zstd_size2=$(echo "$zstd_str" \|awk '{split($0,array,":")} END{print array[1]}')
	(( $zstd_size2 != $zstd_size1 )) && log_fail \
	"ZFS recv failed: compressed size differs ($zstd_size2 != $zstd_size1)"
	zstd_version2=$(echo "$zstd_str" \|awk '{split($0,array,":")} END{print array[2]}')
	zstd_level2=$(echo "$zstd_str" \|awk '{split($0,array,":")} END{print array[3]}')
	log_note "ZSTD dest: size=$zstd_size2 version=$zstd_version2 level=$zstd_level2"
	(( $zstd_level2 != $zstd_level1 )) && log_fail \
	"ZFS recv failed: compression level did not match header level ($zstd_level2 != $zstd_level1)"

	log_pass "ZFS can receive a ZSTD stream and determine the compression level"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_receive/zfs_receive_raw.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_receive/zfs_receive_raw.ksh
	index 9740caf72508..32b05e527ad3 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_receive/zfs_receive_raw.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_receive/zfs_receive_raw.ksh
	@@ -1,94 +1,94 @@
	#!/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) 2017 Datto, Inc. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib

	#
	# DESCRIPTION:
	# ZFS should receive streams from raw sends.
	#
	# STRATEGY:
	# 1. Create an encrypted dataset
	# 2. Create a file and get its checksum
	# 3. Snapshot the dataset
	# 4. Attempt to receive a raw send stream as a child of an unencrypted dataset
	# 5. Verify the key is unavailable
	# 6. Attempt to load the key and mount the dataset
	# 7. Verify the checksum of the file is the same as the original
	# 8. Attempt to receive a raw send stream as a child of an encrypted dataset
	# 9. Verify the key is unavailable
	# 10. Attempt to load the key and mount the dataset
	# 11. Verify the checksum of the file is the same as the original
	# 12. Verify 'zfs receive -n' works with the raw stream
	#

	verify_runnable "both"

	function cleanup
	{
	datasetexists $TESTPOOL/$TESTFS1 && \
	- log_must zfs destroy -r $TESTPOOL/$TESTFS1
	+ destroy_dataset $TESTPOOL/$TESTFS1 -r

	datasetexists $TESTPOOL/$TESTFS2 && \
	- log_must zfs destroy -r $TESTPOOL/$TESTFS2
	+ destroy_dataset $TESTPOOL/$TESTFS2 -r
	}

	log_onexit cleanup

	log_assert "ZFS should receive streams from raw sends"

	typeset passphrase="password"
	typeset snap="$TESTPOOL/$TESTFS1@snap"

	log_must eval "echo $passphrase \| zfs create -o encryption=on" \
	"-o keyformat=passphrase $TESTPOOL/$TESTFS1"

	log_must mkfile 1M /$TESTPOOL/$TESTFS1/$TESTFILE0
	typeset checksum=$(md5digest /$TESTPOOL/$TESTFS1/$TESTFILE0)

	log_must zfs snapshot $snap

	log_note "Verify ZFS can receive a raw send stream from an encrypted dataset"
	log_must eval "zfs send -w $snap \| zfs receive $TESTPOOL/$TESTFS2"

	keystatus=$(get_prop keystatus $TESTPOOL/$TESTFS2)
	[[ "$keystatus" == "unavailable" ]] \|\| \
	log_fail "Expected keystatus unavailable, got $keystatus"

	log_must eval "echo $passphrase \| zfs mount -l $TESTPOOL/$TESTFS2"

	typeset cksum1=$(md5digest /$TESTPOOL/$TESTFS2/$TESTFILE0)
	[[ "$cksum1" == "$checksum" ]] \|\| \
	log_fail "Checksums differ ($cksum1 != $checksum)"

	log_must eval "zfs send -w $snap \| zfs receive $TESTPOOL/$TESTFS1/c1"

	keystatus=$(get_prop keystatus $TESTPOOL/$TESTFS1/c1)
	[[ "$keystatus" == "unavailable" ]] \|\| \
	log_fail "Expected keystatus unavailable, got $keystatus"

	log_must eval "echo $passphrase \| zfs mount -l $TESTPOOL/$TESTFS1/c1"
	typeset cksum2=$(md5digest /$TESTPOOL/$TESTFS1/c1/$TESTFILE0)
	[[ "$cksum2" == "$checksum" ]] \|\| \
	log_fail "Checksums differ ($cksum2 != $checksum)"

	log_must eval "zfs send -w $snap \| zfs receive -n $TESTPOOL/$TESTFS3"

	log_pass "ZFS can receive streams from raw sends"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_receive/zfs_receive_raw_-d.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_receive/zfs_receive_raw_-d.ksh
	index a909f2788ba1..662f9386ebee 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_receive/zfs_receive_raw_-d.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_receive/zfs_receive_raw_-d.ksh
	@@ -1,62 +1,62 @@
	#!/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

	#
	# DESCRIPTION:
	# zfs receive -d should create the expected encryption hierarchy.
	#
	# STRATEGY:
	# 1. Create an encrypted dataset and a inheriting child
	# 2. Snapshot the child dataset
	# 2. Create a recursive raw send file from the snapshot
	# 3. Destroy the original child filesystem
	# 4. Receive the snapshot as a child of the second dataset with '-d'
	# 5. Verify the new child can be mounted
	#

	verify_runnable "both"

	function cleanup
	{
	datasetexists $TESTPOOL/$TESTFS1 && \
	- log_must zfs destroy -r $TESTPOOL/$TESTFS1
	+ destroy_dataset $TESTPOOL/$TESTFS1 -r
	rm -f $sendfile
	}

	log_onexit cleanup

	log_assert "zfs receive -d should create the expected encryption hierarchy"

	typeset passphrase="password1"

	sendfile=$TEST_BASE_DIR/sendfile.$$

	log_must eval "echo $passphrase \| zfs create -o encryption=on" \
	"-o keyformat=passphrase $TESTPOOL/$TESTFS1"
	log_must zfs create $TESTPOOL/$TESTFS1/child
	log_must zfs snapshot $TESTPOOL/$TESTFS1/child@snap
	log_must eval "zfs send -Rw $TESTPOOL/$TESTFS1/child@snap > $sendfile"
	log_must zfs destroy -r $TESTPOOL/$TESTFS1/child
	log_must zfs receive -Fd $TESTPOOL < $sendfile
	log_must eval "echo $passphrase \| zfs mount -l $TESTPOOL/$TESTFS1/child"

	log_pass "zfs receive -d creates the expected encryption hierarchy"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_receive/zfs_receive_raw_incremental.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_receive/zfs_receive_raw_incremental.ksh
	index 964c80657da3..7826ec9a4890 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_receive/zfs_receive_raw_incremental.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_receive/zfs_receive_raw_incremental.ksh
	@@ -1,96 +1,96 @@
	#!/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) 2017 Datto, Inc. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib

	#
	# DESCRIPTION:
	# ZFS should receive streams from raw incremental sends.
	#
	# STRATEGY:
	# 1. Create an encrypted dataset
	# 2. Snapshot the dataset
	# 3. Create a file and get its checksum
	# 4. Snapshot the dataset
	# 5. Attempt to receive a raw send stream of the first snapshot
	# 6. Change the passphrase required to unlock the original filesystem
	# 7. Attempt and intentionally fail to receive the second snapshot
	# 8. Verify that the required passphrase hasn't changed on the receive side
	# 9. Attempt a real raw incremental send stream of the second snapshot
	# 10. Attempt load the key and mount the dataset
	# 11. Verify the checksum of the file is the same as the original
	#

	verify_runnable "both"

	function cleanup
	{
	datasetexists $TESTPOOL/$TESTFS1 && \
	- log_must zfs destroy -r $TESTPOOL/$TESTFS1
	+ destroy_dataset $TESTPOOL/$TESTFS1 -r

	datasetexists $TESTPOOL/$TESTFS2 && \
	- log_must zfs destroy -r $TESTPOOL/$TESTFS2
	+ destroy_dataset $TESTPOOL/$TESTFS2 -r

	[[ -f $ibackup ]] && log_must rm -f $ibackup
	[[ -f $ibackup_trunc ]] && log_must rm -f $ibackup_trunc
	}

	log_onexit cleanup

	log_assert "ZFS should receive streams from raw incremental sends"

	typeset ibackup="$TEST_BASE_DIR/ibackup.$$"
	typeset ibackup_trunc="$TEST_BASE_DIR/ibackup_trunc.$$"
	typeset passphrase="password"
	typeset passphrase2="password2"
	typeset snap1="$TESTPOOL/$TESTFS1@snap1"
	typeset snap2="$TESTPOOL/$TESTFS1@snap2"

	log_must eval "echo $passphrase \| zfs create -o encryption=on" \
	"-o keyformat=passphrase $TESTPOOL/$TESTFS1"

	log_must zfs snapshot $snap1

	log_must mkfile 1M /$TESTPOOL/$TESTFS1/$TESTFILE0
	typeset checksum=$(md5digest /$TESTPOOL/$TESTFS1/$TESTFILE0)

	log_must zfs snapshot $snap2

	log_must eval "zfs send -w $snap1 \| zfs receive $TESTPOOL/$TESTFS2"
	log_must eval "echo $passphrase2 \| zfs change-key $TESTPOOL/$TESTFS1"
	log_must eval "zfs send -w -i $snap1 $snap2 > $ibackup"

	typeset trunc_size=$(stat_size $ibackup)
	trunc_size=$(expr $trunc_size - 64)
	log_must cp $ibackup $ibackup_trunc
	log_must truncate -s $trunc_size $ibackup_trunc
	log_mustnot eval "zfs receive $TESTPOOL/$TESTFS2 < $ibackup_trunc"
	log_mustnot eval "echo $passphrase2 \| zfs load-key $TESTPOOL/$TESTFS2"
	log_must eval "echo $passphrase \| zfs load-key $TESTPOOL/$TESTFS2"
	log_must zfs unload-key $TESTPOOL/$TESTFS2

	log_must eval "zfs receive $TESTPOOL/$TESTFS2 < $ibackup"
	log_must eval "echo $passphrase2 \| zfs mount -l $TESTPOOL/$TESTFS2"

	typeset cksum1=$(md5digest /$TESTPOOL/$TESTFS2/$TESTFILE0)
	[[ "$cksum1" == "$checksum" ]] \|\| \
	log_fail "Checksums differ ($cksum1 != $checksum)"

	log_pass "ZFS can receive streams from raw incremental sends"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_receive/zfs_receive_to_encrypted.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_receive/zfs_receive_to_encrypted.ksh
	index f8e53f02c23d..526497401f28 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_receive/zfs_receive_to_encrypted.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_receive/zfs_receive_to_encrypted.ksh
	@@ -1,77 +1,77 @@
	#!/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) 2017 Datto, Inc. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib

	#
	# DESCRIPTION:
	# ZFS should receive to an encrypted child dataset.
	#
	# STRATEGY:
	# 1. Snapshot the default dataset
	# 2. Create an encrypted dataset
	# 3. Attempt to receive a stream to an encrypted child
	# 4. Attempt to receive a stream with properties to an encrypted child
	# 5. Attempt to receive a replication stream to an encrypted child
	# 6. Unmount and unload the encrypted dataset keys
	# 7. Attempt to receive a snapshot stream to an encrypted child
	#

	verify_runnable "both"

	function cleanup
	{
	- snapexists $snap && log_must_busy zfs destroy -f $snap
	+ snapexists $snap && destroy_dataset $snap -f

	datasetexists $TESTPOOL/$TESTFS1 && \
	- log_must zfs destroy -r $TESTPOOL/$TESTFS1
	+ destroy_dataset $TESTPOOL/$TESTFS1 -r
	}

	log_onexit cleanup

	log_assert "ZFS should receive encrypted filesystems into child dataset"

	typeset passphrase="password"
	typeset snap="$TESTPOOL/$TESTFS@snap"
	typeset testfile="testfile"

	log_must zfs snapshot $snap

	log_must eval "echo $passphrase \| zfs create -o encryption=on" \
	"-o keyformat=passphrase $TESTPOOL/$TESTFS1"

	log_note "Verifying ZFS will receive to an encrypted child"
	log_must eval "zfs send $snap \| zfs receive $TESTPOOL/$TESTFS1/c1"

	log_note "Verifying 'send -p' will receive to an encrypted child"
	log_must eval "zfs send -p $snap \| zfs receive $TESTPOOL/$TESTFS1/c2"
	log_must test "$(get_prop 'encryption' $TESTPOOL/$TESTFS1/c2)" == "off"

	log_note "Verifying 'send -R' will receive to an encrypted child"
	log_must eval "zfs send -R $snap \| zfs receive $TESTPOOL/$TESTFS1/c3"
	log_must test "$(get_prop 'encryption' $TESTPOOL/$TESTFS1/c3)" == "off"

	log_note "Verifying ZFS will not receive to an encrypted child when the" \
	"parent key is unloaded"
	log_must zfs unmount $TESTPOOL/$TESTFS1
	log_must zfs unload-key $TESTPOOL/$TESTFS1
	log_mustnot eval "zfs send $snap \| zfs receive $TESTPOOL/$TESTFS1/c4"

	log_pass "ZFS can receive encrypted filesystems into child dataset"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_rename/zfs_rename.kshlib b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_rename/zfs_rename.kshlib
	index 9b8fb6b0edc1..af1c2f7bedaf 100644
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_rename/zfs_rename.kshlib
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_rename/zfs_rename.kshlib
	@@ -1,129 +1,127 @@
	#
	# 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) 2012, 2016 by Delphix. All rights reserved.
	#

	. $STF_SUITE/tests/functional/cli_root/zfs_rename/zfs_rename.cfg

	function additional_setup
	{
	# Create testfile
	log_must cp $DATA $TESTDIR/$TESTFILE0
	log_must cp $DATA $TESTDIR1/$TESTFILE0

	# Create snapshot
	if ! snapexists $TESTPOOL/$TESTFS@snapshot; then
	log_must zfs snapshot $TESTPOOL/$TESTFS@snapshot
	log_must zfs clone $TESTPOOL/$TESTFS@snapshot \
	$TESTPOOL/$TESTFS-clone
	fi

	# Create file system
	datasetexists $TESTPOOL/$TESTFS1 \|\| \
	log_must zfs create $TESTPOOL/$TESTFS1

	# Create testfile
	log_must cp $DATA $(get_prop mountpoint $TESTPOOL/$TESTFS1)/$TESTFILE0

	# Create container
	datasetexists $TESTPOOL/$TESTCTR1 \|\| \
	log_must zfs create $TESTPOOL/$TESTCTR1
	log_must cp $DATA $(get_prop mountpoint $TESTPOOL/$TESTCTR1)/$TESTFILE0

	# Create data in zvol
	if is_global_zone; then
	log_must eval "dd if=$DATA of=$VOL_R_PATH bs=$BS count=$CNT \
	>/dev/null 2>&1"
	else
	log_must cp $DATA $(get_prop mountpoint $TESTPOOL/$TESTVOL)/$TESTFILE0
	fi

	# Create temporary %recv clone
	create_recv_clone $TESTPOOL/$RECVFS
	}

	function rename_dataset # src dest
	{
	typeset src=$1
	typeset dest=$2

	log_must zfs rename $src $dest
	block_device_wait

	#
	# Verify src name no longer in use
	#
	log_mustnot datasetexists $src
	log_must datasetexists $dest
	}

	function cleanup
	{
	typeset -i i=0
	while ((i < ${#dataset[*]} )); do
	if ! datasetexists ${dataset[i]}-new ; then
	((i = i + 1))
	continue
	fi

	if [[ ${dataset[i]}-new != @ ]] ; then
	zfs rename ${dataset[i]}-new ${dataset[i]}
	if [[ $? -ne 0 ]]; then
	typeset newfs=${dataset[i]}-new
	typeset oldfs=${dataset[i]}
	typeset mntp=$(get_prop mountpoint $newfs)
	log_must zfs destroy -f $newfs
	log_must zfs create -p $oldfs
	log_must zfs set mountpoint=$mntp $oldfs
	fi
	else
	log_must zfs destroy -fR ${dataset[i]}-new
	fi

	((i = i + 1))
	done

	- if snapexists $TESTPOOL/$TESTFS@snapshot; then
	- log_must zfs destroy -fR $TESTPOOL/$TESTFS@snapshot
	- fi
	+ snapexists $TESTPOOL/$TESTFS@snapshot && \
	+ destroy_dataset $TESTPOOL/$TESTFS@snapshot -fR

	- if datasetexists $TESTPOOL/$RECVFS; then
	- log_must zfs destroy -r $TESTPOOL/$RECVFS
	- fi
	+ datasetexists $TESTPOOL/$RECVFS && \
	+ destroy_dataset $TESTPOOL/$RECVFS -r
	}

	function cmp_data #<$1 src data, $2 tgt data>
	{
	typeset src=$1
	typeset tgt=$2

	cmp $src $tgt >/dev/null 2>&1

	return $?
	}

	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_rename/zfs_rename_003_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_rename/zfs_rename_003_pos.ksh
	index 56c06cfe857d..0bd4aca3a7fd 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_rename/zfs_rename_003_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_rename/zfs_rename_003_pos.ksh
	@@ -1,68 +1,68 @@
	#!/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.
	#

	. $STF_SUITE/include/libtest.shlib

	#
	# DESCRIPTION:
	# 'zfs rename' can address the abbreviated snapshot name.
	#
	# STRATEGY:
	# 1. Create pool, fs and snap.
	# 2. Verify 'zfs rename' support the abbreviated snapshot name.
	#

	verify_runnable "both"

	function cleanup
	{
	- datasetexists $snap && log_must zfs destroy $snap
	+ datasetexists $snap && destroy_dataset $snap
	}

	log_assert "'zfs rename' can address the abbreviated snapshot name."
	log_onexit cleanup

	fs=$TESTPOOL/$TESTFS; snap=$fs@snap
	set -A newname "$fs@new-snap" "@new-snap" "new-snap"

	log_must zfs snapshot $snap
	log_must datasetexists $snap

	typeset -i i=0
	while ((i < ${#newname[*]} )); do
	log_must zfs rename $snap ${newname[$i]}
	log_must datasetexists ${snap%%@}@${newname[$i]##@}
	log_must zfs rename ${snap%%@}@${newname[$i]##@} $snap

	((i += 1))
	done

	log_pass "'zfs rename' address the abbreviated snapshot name passed."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_rename/zfs_rename_007_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_rename/zfs_rename_007_pos.ksh
	index 0cacb7a98fa2..2a3f8a8ccd7b 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_rename/zfs_rename_007_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_rename/zfs_rename_007_pos.ksh
	@@ -1,155 +1,154 @@
	#!/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) 2012, 2016 by Delphix. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/cli_root/zfs_rename/zfs_rename.kshlib

	#
	# DESCRIPTION:
	# Rename dataset, verify that the data haven't changed.
	#
	# STRATEGY:
	# 1. Create random data and copy to dataset.
	# 2. Perform renaming commands.
	# 3. Verify that the data haven't changed.
	#

	verify_runnable "both"

	function cleanup
	{
	- if datasetexists $TESTPOOL/$TESTFS ; then
	- log_must zfs destroy -Rf $TESTPOOL/$TESTFS
	- fi
	+ datasetexists $TESTPOOL/$TESTFS && \
	+ destroy_dataset $TESTPOOL/$TESTFS -Rf
	log_must zfs create $TESTPOOL/$TESTFS
	log_must zfs set mountpoint=$TESTDIR $TESTPOOL/$TESTFS

	rm -f $SRC_FILE $DST_FILE
	}

	function target_obj
	{
	typeset dtst=$1

	typeset obj
	typeset type=$(get_prop type $dtst)
	if [[ $type == "filesystem" ]]; then
	obj=$(get_prop mountpoint $dtst)/${SRC_FILE##*/}
	elif [[ $type == "volume" ]]; then
	obj=$ZVOL_DEVDIR/$dtst
	fi

	echo $obj
	}

	log_assert "Rename dataset, verify that the data haven't changed."
	log_onexit cleanup

	# Generate random data
	#
	BS=512 ; CNT=2048
	SRC_FILE=$TESTDIR/srcfile.$$
	DST_FILE=$TESTDIR/dstfile.$$
	log_must dd if=/dev/urandom of=$SRC_FILE bs=$BS count=$CNT

	fs=$TESTPOOL/$TESTFS/fs.$$
	fsclone=$TESTPOOL/$TESTFS/fsclone.$$
	log_must zfs create $fs

	obj=$(target_obj $fs)
	log_must cp $SRC_FILE $obj

	snap=${fs}@snap.$$
	log_must zfs snapshot $snap
	log_must zfs clone $snap $fsclone

	# Rename dataset & clone
	#
	log_must zfs rename $fs ${fs}-new
	log_must zfs rename $fsclone ${fsclone}-new

	# Compare source file and target file
	#
	obj=$(target_obj ${fs}-new)
	log_must diff $SRC_FILE $obj
	obj=$(target_obj ${fsclone}-new)
	log_must diff $SRC_FILE $obj

	# Rename snapshot and re-clone dataset
	#
	log_must zfs rename ${fs}-new $fs
	log_must zfs rename $snap ${snap}-new
	log_must zfs clone ${snap}-new $fsclone

	# Compare source file and target file
	#
	obj=$(target_obj $fsclone)
	log_must diff $SRC_FILE $obj

	if is_global_zone; then
	vol=$TESTPOOL/$TESTFS/vol.$$ ; volclone=$TESTPOOL/$TESTFS/volclone.$$
	log_must zfs create -V 100M $vol

	obj=$(target_obj $vol)
	block_device_wait $obj
	log_must dd if=$SRC_FILE of=$obj bs=$BS count=$CNT

	snap=${vol}@snap.$$
	log_must zfs snapshot $snap
	log_must zfs clone $snap $volclone

	# Rename dataset & clone
	log_must zfs rename $vol ${vol}-new
	log_must zfs rename $volclone ${volclone}-new

	# Compare source file and target file
	obj=$(target_obj ${vol}-new)
	block_device_wait $obj
	log_must dd if=$obj of=$DST_FILE bs=$BS count=$CNT
	log_must diff $SRC_FILE $DST_FILE
	obj=$(target_obj ${volclone}-new)
	block_device_wait $obj
	log_must dd if=$obj of=$DST_FILE bs=$BS count=$CNT
	log_must diff $SRC_FILE $DST_FILE

	# Rename snapshot and re-clone dataset
	log_must zfs rename ${vol}-new $vol
	log_must zfs rename $snap ${snap}-new
	log_must zfs clone ${snap}-new $volclone

	# Compare source file and target file
	obj=$(target_obj $volclone)
	block_device_wait $obj
	log_must dd if=$obj of=$DST_FILE bs=$BS count=$CNT
	log_must diff $SRC_FILE $DST_FILE
	fi

	log_pass "Rename dataset, the data haven't changed passed."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_rename/zfs_rename_008_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_rename/zfs_rename_008_pos.ksh
	index 3fc099d79f8a..229163839058 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_rename/zfs_rename_008_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_rename/zfs_rename_008_pos.ksh
	@@ -1,88 +1,87 @@
	#!/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) 2012, 2016 by Delphix. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib

	#
	# DESCRIPTION:
	# zfs rename -r can rename snapshot recursively.
	#
	# STRATEGY:
	# 1. Create snapshot recursively.
	# 2. Rename snapshot recursively.
	# 3. Verify rename -r snapshot correctly.
	#

	verify_runnable "both"

	function cleanup
	{
	typeset -i i=0
	while ((i < ${#datasets[@]})); do
	- if datasetexists ${datasets[$i]}@snap ; then
	- log_must zfs destroy ${datasets[$i]}@snap
	- fi
	- if datasetexists ${datasets[$i]}@snap-new ; then
	- log_must zfs destroy ${datasets[$i]}@snap-new
	- fi
	+ datasetexists ${datasets[$i]}@snap && \
	+ destroy_dataset ${datasets[$i]}@snap
	+
	+ datasetexists ${datasets[$i]}@snap-new && \
	+ destroy_dataset ${datasets[$i]}@snap-new

	((i += 1))
	done
	}

	log_assert "zfs rename -r can rename snapshot recursively."
	log_onexit cleanup

	set -A datasets $TESTPOOL $TESTPOOL/$TESTCTR \
	$TESTPOOL/$TESTCTR/$TESTFS1 $TESTPOOL/$TESTFS
	if is_global_zone; then
	datasets[${#datasets[@]}]=$TESTPOOL/$TESTVOL
	fi

	log_must zfs snapshot -r ${TESTPOOL}@snap
	typeset -i i=0
	while ((i < ${#datasets[@]})); do
	log_must datasetexists ${datasets[$i]}@snap

	((i += 1))
	done

	log_must zfs rename -r ${TESTPOOL}@snap ${TESTPOOL}@snap-new
	i=0
	while ((i < ${#datasets[@]})); do
	log_must datasetexists ${datasets[$i]}@snap-new

	((i += 1))
	done

	log_must zfs destroy -rf ${TESTPOOL}@snap-new

	log_pass "Verify zfs rename -r passed."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_rename/zfs_rename_011_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_rename/zfs_rename_011_pos.ksh
	index 2d1220e334c9..71d72619d646 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_rename/zfs_rename_011_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_rename/zfs_rename_011_pos.ksh
	@@ -1,78 +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 2009 Sun Microsystems, Inc. All rights reserved.
	# Use is subject to license terms.
	#

	#
	# Copyright (c) 2016 by Delphix. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/cli_root/zfs_rename/zfs_rename.kshlib

	#
	# DESCRIPTION
	# 'zfs rename -p' should work as expected
	#
	# STRATEGY:
	# 1. Make sure the upper level of $newdataset does not exist
	# 2. Make sure without -p option, 'zfs rename' will fail
	# 3. With -p option, rename works
	#

	verify_runnable "both"

	function additional_cleanup
	{
	- if datasetexists $TESTPOOL/notexist ; then
	- log_must zfs destroy -Rf $TESTPOOL/notexist
	- fi
	+ datasetexists $TESTPOOL/notexist && \
	+ destroy_dataset $TESTPOOL/notexist -Rf
	+
	+ datasetexists $TESTPOOL/$TESTFS && \
	+ destroy_dataset $TESTPOOL/$TESTFS -Rf

	- if datasetexists $TESTPOOL/$TESTFS ; then
	- log_must zfs destroy -Rf $TESTPOOL/$TESTFS
	- fi
	log_must zfs create $TESTPOOL/$TESTFS

	if is_global_zone ; then
	- if datasetexists $TESTPOOL/$TESTVOL ; then
	- log_must zfs destroy -Rf $TESTPOOL/$TESTVOL
	- fi
	+ datasetexists $TESTPOOL/$TESTVOL && \
	+ destroy_dataset $TESTPOOL/$TESTVOL -Rf
	+
	log_must zfs create -V $VOLSIZE $TESTPOOL/$TESTVOL
	fi
	}

	log_onexit additional_cleanup

	log_assert "'zfs rename -p' should work as expected"

	log_must verify_opt_p_ops "rename" "fs" "$TESTPOOL/$TESTFS" \
	"$TESTPOOL/notexist/new/$TESTFS1"

	if is_global_zone; then
	log_must verify_opt_p_ops "rename" "vol" "$TESTPOOL/$TESTVOL" \
	"$TESTPOOL/notexist/new/$TESTVOL1"
	fi

	log_pass "'zfs rename -p' should work as expected"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_rename/zfs_rename_013_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_rename/zfs_rename_013_pos.ksh
	index b2e01006fdd1..73790f58cd45 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_rename/zfs_rename_013_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_rename/zfs_rename_013_pos.ksh
	@@ -1,85 +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) 2012, 2016 by Delphix. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib

	#
	# DESCRIPTION:
	# zfs rename -r can rename snapshot when child datasets
	# don't have a snapshot of the given name.
	#
	# STRATEGY:
	# 1. Create snapshot.
	# 2. Rename snapshot recursively.
	# 3. Verify rename -r snapshot correctly.
	#

	verify_runnable "both"

	function cleanup
	{
	- if datasetexists $TESTPOOL/$TESTCTR@snap-new ; then
	- log_must zfs destroy -f $TESTPOOL/$TESTCTR@snap-new
	- fi
	+ datasetexists $TESTPOOL/$TESTCTR@snap-new && \
	+ destroy_dataset $TESTPOOL/$TESTCTR@snap-new -f

	- if datasetexists $TESTPOOL/$TESTCTR@snap ; then
	- log_must zfs destroy -f $TESTPOOL/$TESTCTR@snap
	- fi
	+ datasetexists $TESTPOOL/$TESTCTR@snap && \
	+ destroy_dataset $TESTPOOL/$TESTCTR@snap -f

	- if datasetexists $TESTPOOL@snap-new ; then
	- log_must zfs destroy -f $TESTPOOL@snap-new
	- fi
	+ datasetexists $TESTPOOL@snap-new && \
	+ destroy_dataset $TESTPOOL@snap-new -f

	- if datasetexists $TESTPOOL@snap ; then
	- log_must zfs destroy -f $TESTPOOL@snap
	- fi
	+ datasetexists $TESTPOOL@snap && \
	+ destroy_dataset $TESTPOOL@snap -f
	}

	log_assert "zfs rename -r can rename snapshot when child datasets" \
	"don't have a snapshot of the given name."

	log_onexit cleanup

	log_must zfs snapshot $TESTPOOL/$TESTCTR@snap
	log_must zfs rename -r $TESTPOOL/$TESTCTR@snap $TESTPOOL/$TESTCTR@snap-new
	log_must datasetexists $TESTPOOL/$TESTCTR@snap-new

	log_must zfs snapshot $TESTPOOL@snap
	log_must zfs rename -r $TESTPOOL@snap $TESTPOOL@snap-new
	log_must datasetexists $TESTPOOL/$TESTCTR@snap-new
	log_must datasetexists $TESTPOOL@snap-new

	log_must zfs destroy -f $TESTPOOL/$TESTCTR@snap-new
	log_must zfs destroy -f $TESTPOOL@snap-new

	log_pass "Verify zfs rename -r passed when child datasets" \
	"don't have a snapshot of the given name."

	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_rename/zfs_rename_encrypted_child.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_rename/zfs_rename_encrypted_child.ksh
	index fa57658f185b..2366cf67655c 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_rename/zfs_rename_encrypted_child.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_rename/zfs_rename_encrypted_child.ksh
	@@ -1,78 +1,78 @@
	#!/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) 2017 Datto, Inc. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/cli_root/zfs_load-key/zfs_load-key_common.kshlib

	#
	# DESCRIPTION:
	# 'zfs rename' should not move an encrypted child dataset outside of its
	# encryption root.
	#
	# STRATEGY:
	# 1. Create two encryption roots, and a child and grandchild of the first
	# encryption root
	# 2. Attempt to rename the grandchild under an unencrypted parent
	# 3. Attempt to rename the grandchild under a different encrypted parent
	# 4. Attempt to rename the grandchild under the current parent
	# 5. Verify the encryption root of the dataset
	# 6. Attempt to rename the grandchild to a child
	# 7. Verify the encryption root of the dataset
	#

	verify_runnable "both"

	function cleanup
	{
	datasetexists $TESTPOOL/$TESTFS2 && \
	- log_must zfs destroy -r $TESTPOOL/$TESTFS2
	+ destroy_dataset $TESTPOOL/$TESTFS2 -r
	datasetexists $TESTPOOL/$TESTFS3 && \
	- log_must zfs destroy -r $TESTPOOL/$TESTFS3
	+ destroy_dataset $TESTPOOL/$TESTFS3 -r
	}
	log_onexit cleanup

	log_assert "'zfs rename' should not move an encrypted child outside of its" \
	"encryption root"

	log_must eval "echo $PASSPHRASE \| zfs create -o encryption=on" \
	"-o keyformat=passphrase -o keylocation=prompt $TESTPOOL/$TESTFS2"
	log_must zfs create $TESTPOOL/$TESTFS2/child
	log_must zfs create $TESTPOOL/$TESTFS2/child/grandchild
	log_must eval "echo $PASSPHRASE1 \| zfs create -o encryption=on" \
	"-o keyformat=passphrase -o keylocation=prompt $TESTPOOL/$TESTFS3"

	log_mustnot zfs rename $TESTPOOL/$TESTFS2/child/grandchild \
	$TESTPOOL/grandchild

	log_mustnot zfs rename $TESTPOOL/$TESTFS2/child/grandchild \
	$TESTPOOL/$TESTFS3/grandchild

	log_must zfs rename $TESTPOOL/$TESTFS2/child/grandchild \
	$TESTPOOL/$TESTFS2/child/grandchild2
	log_must verify_encryption_root $TESTPOOL/$TESTFS2/child/grandchild2 \
	$TESTPOOL/$TESTFS2

	log_must zfs rename $TESTPOOL/$TESTFS2/child/grandchild2 \
	$TESTPOOL/$TESTFS2/grandchild2
	log_must verify_encryption_root $TESTPOOL/$TESTFS2/grandchild2 \
	$TESTPOOL/$TESTFS2

	log_pass "'zfs rename' does not move an encrypted child outside of its" \
	"encryption root"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_rename/zfs_rename_to_encrypted.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_rename/zfs_rename_to_encrypted.ksh
	index 1b9c6e3c704f..ab8e1c89ae86 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_rename/zfs_rename_to_encrypted.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_rename/zfs_rename_to_encrypted.ksh
	@@ -1,53 +1,53 @@
	#!/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) 2017 Datto, Inc. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/cli_root/zfs_load-key/zfs_load-key_common.kshlib

	#
	# DESCRIPTION:
	# 'zfs rename' should be able to move an unencrypted dataset to a child
	# of an encrypted dataset
	#
	# STRATEGY:
	# 1. Create an encrypted dataset
	# 2. Rename the default dataset to a child of the encrypted dataset
	# 3. Confirm the child dataset doesn't have any encryption properties
	#

	verify_runnable "both"

	function cleanup
	{
	datasetexists $TESTPOOL/$TESTFS2 && \
	- log_must zfs destroy -r $TESTPOOL/$TESTFS2
	+ destroy_dataset $TESTPOOL/$TESTFS2 -r
	}
	log_onexit cleanup

	log_assert "'zfs rename' should allow renaming an unencrypted dataset to a" \
	"child of an encrypted dataset"

	log_must eval "echo $PASSPHRASE \| zfs create -o encryption=on" \
	"-o keyformat=passphrase -o keylocation=prompt $TESTPOOL/$TESTFS2"
	log_must zfs rename $TESTPOOL/$TESTFS $TESTPOOL/$TESTFS2/$TESTFS
	log_must test "$(get_prop 'encryption' $TESTPOOL/$TESTFS2/$TESTFS)" == "off"

	log_pass "'zfs rename' allows renaming an unencrypted dataset to a child" \
	"of an encrypted dataset"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_rollback/zfs_rollback_001_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_rollback/zfs_rollback_001_pos.ksh
	index 342c72e166a9..607bbf06eafd 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_rollback/zfs_rollback_001_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_rollback/zfs_rollback_001_pos.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 2008 Sun Microsystems, Inc. All rights reserved.
	# Use is subject to license terms.
	#

	#
	# Copyright (c) 2016 by Delphix. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/cli_root/zfs_rollback/zfs_rollback_common.kshlib

	#
	# DESCRIPTION:
	# 'zfs rollback -r\|-rf\|-R\|-Rf' will recursively destroy any snapshots
	# more recent than the one specified.
	#
	# STRATEGY:
	# 1. Create pool, fs & volume.
	# 2. Separately create three snapshots or clones for fs & volume
	# 3. Roll back to the second snapshot and check the results.
	# 4. Create the third snapshot or clones for fs & volume again.
	# 5. Roll back to the first snapshot and check the results.
	# 6. Separately create two snapshots for fs & volume.
	# 7. Roll back to the first snapshot and check the results.
	#

	verify_runnable "both"

	log_assert "'zfs rollback -r\|-rf\|-R\|-Rf' will recursively destroy any " \
	"snapshots more recent than the one specified."
	log_onexit cleanup_env

	#
	# Create suitable test environment and run 'zfs rollback', then compare with
	# expected value to check the system status.
	#
	# $1 option.
	# $2 the number of snapshots or clones.
	# $3 the number of snapshot point which we want to rollback.
	#
	function test_n_check #opt num_snap_clone num_rollback
	{
	typeset opt=$1
	typeset -i cnt=$2
	typeset -i pointcnt=$3
	typeset dtst

	(( cnt > 3 \|\| pointcnt > cnt )) && \
	log_fail "Unsupported testing condition."

	# Clean up the test environment
	if pgrep -x dd 2>/dev/null; then
	pkill -x dd
	fi

	- datasetexists $FS && log_must zfs destroy -Rf $FS
	+ datasetexists $FS && destroy_dataset $FS -Rf
	if datasetexists $VOL; then
	if ismounted $TESTDIR1 $NEWFS_DEFAULT_FS; then
	log_must umount -f $TESTDIR1
	sleep 0.1
	fi

	- log_must zfs destroy -Rf $VOL
	+ destroy_dataset $VOL -Rf
	fi

	# Create specified test environment
	case $opt in
	r) setup_snap_env $cnt ;;
	R) setup_clone_env $cnt ;;
	esac

	all_snap="$TESTSNAP $TESTSNAP1 $TESTSNAP2"
	all_clone="$TESTCLONE $TESTCLONE1 $TESTCLONE2"
	typeset snap_point
	typeset exist_snap
	typeset exist_clone
	case $pointcnt in
	1) snap_point=$TESTSNAP
	exist_snap=$TESTSNAP
	[[ $opt == R ]] && exist_clone=$TESTCLONE
	;;
	2) snap_point=$TESTSNAP1
	exist_snap="$TESTSNAP $TESTSNAP1"
	[[ $opt == R ]] && exist_clone="$TESTCLONE $TESTCLONE1"
	;;
	esac

	typeset snap
	for dtst in $FS $VOL; do
	# Volume is not available in Local Zone.
	if [[ $dtst == $VOL ]]; then
	if ! is_global_zone; then
	break
	fi
	fi
	if [[ $opt == f ]]; then
	# To write data to the mountpoint directory,
	write_mountpoint_dir $dtst
	opt=${opt%f}
	fi

	if [[ $dtst == $VOL ]]; then
	if ismounted $TESTDIR1 $NEWFS_DEFAULT_FS; then
	log_must umount -f $TESTDIR1
	fi
	log_must zfs rollback $opt $dtst@$snap_point
	log_must mount \
	$ZVOL_DEVDIR/$TESTPOOL/$TESTVOL $TESTDIR1
	else
	log_must zfs rollback $opt $dtst@$snap_point
	fi

	for snap in $all_snap; do
	if [[ " $exist_snap " == " $snap " ]]; then
	log_must datasetexists $dtst@$snap
	else
	log_must datasetnonexists $dtst@$snap
	fi
	done
	for clone in $all_clone; do
	if [[ " $exist_clone " == " $clone " ]]; then
	log_must datasetexists $dtst$clone
	else
	log_must datasetnonexists $dtst$clone
	fi
	done

	check_files $dtst@$snap_point
	done
	}

	typeset opt
	for opt in "-r" "-rf" "-R" "-Rf"; do
	#
	# Currently, the test case was limited to create and rollback
	# in three snapshots
	#
	log_note "Create 3 snapshots, rollback to the 2nd snapshot " \
	"using $opt."
	test_n_check "$opt" 3 2

	log_note "Create 3 snapshots and rollback to the 1st snapshot " \
	"using $opt."
	test_n_check "$opt" 3 1

	log_note "Create 2 snapshots and rollback to the 1st snapshot " \
	"using $opt."
	test_n_check "$opt" 2 1
	done

	log_pass "'zfs rollback -r\|-rf\|-R\|-Rf' recursively destroy any snapshots more "\
	"recent than the one specified passed."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_rollback/zfs_rollback_003_neg.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_rollback/zfs_rollback_003_neg.ksh
	index 0ae13d3a9bad..1e3109108bae 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_rollback/zfs_rollback_003_neg.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_rollback/zfs_rollback_003_neg.ksh
	@@ -1,84 +1,82 @@
	#!/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) 2016 by Delphix. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/cli_root/zfs_rollback/zfs_rollback_common.kshlib

	#
	# DESCRIPTION:
	# Separately verify 'zfs rollback ''\|-f\|-r\|-rf\|-R\|-rR will fail in
	# different conditions.
	#
	# STRATEGY:
	# 1. Create pool and file system
	# 2. Create 'snap' and 'snap1' of this file system.
	# 3. Run 'zfs rollback ""\|-f <snap>' and it should fail.
	# 4. Create 'clone1' based on 'snap1'.
	# 5. Run 'zfs rollback -r\|-rf <snap>' and it should fail.
	#

	verify_runnable "both"

	function cleanup
	{
	pkill ${DD##*/}
	for snap in $FSSNAP0 $FSSNAP1 $FSSNAP2; do
	- if snapexists $snap; then
	- log_must zfs destroy -Rf $snap
	- fi
	+ snapexists $snap && destroy_dataset $snap -Rf
	done
	}

	log_assert "Separately verify 'zfs rollback ''\|-f\|-r\|-rf will fail in " \
	"different conditions."
	log_onexit cleanup

	# Create snapshot1 and snapshot2 for this file system.
	#
	create_snapshot $TESTPOOL/$TESTFS $TESTSNAP
	create_snapshot $TESTPOOL/$TESTFS $TESTSNAP1

	# Run 'zfs rollback ""\|-f <snap>' and it should fail.
	#
	log_mustnot zfs rollback $TESTPOOL/$TESTFS@$TESTSNAP
	log_mustnot zfs rollback -f $TESTPOOL/$TESTFS@$TESTSNAP

	# Create 'clone1' based on 'snap1'.
	#
	create_clone $TESTPOOL/$TESTFS@$TESTSNAP1 $TESTPOOL/$TESTCLONE1

	# Run 'zfs rollback -r\|-rf <snap>' and it should fail.
	#
	log_mustnot zfs rollback -r $TESTPOOL/$TESTFS@$TESTSNAP
	log_mustnot zfs rollback -rf $TESTPOOL/$TESTFS@$TESTSNAP

	log_pass "zfs rollback ''\|-f\|-r\|-rf will fail in different conditions " \
	"passed."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_rollback/zfs_rollback_004_neg.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_rollback/zfs_rollback_004_neg.ksh
	index 0c1bb730e77c..9537d5077b1a 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_rollback/zfs_rollback_004_neg.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_rollback/zfs_rollback_004_neg.ksh
	@@ -1,86 +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) 2016 by Delphix. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/cli_root/zfs_rollback/zfs_rollback_common.kshlib

	#
	# DESCRIPTION:
	# 'zfs rollback' should fail when passing invalid options, too many
	# arguments,non-snapshot datasets or missing datasets
	#
	# STRATEGY:
	# 1. Create an array of invalid options
	# 2. Execute 'zfs rollback' with invalid options, too many arguments
	# or missing datasets
	# 3. Verify 'zfs rollback' return with errors
	#

	verify_runnable "both"

	function cleanup
	{
	typeset ds

	for ds in $TESTPOOL $TESTPOOL/$TESTFS $TESTPOOL/$TESTVOL; do
	- if snapexists ${ds}@$TESTSNAP; then
	- log_must zfs destroy ${ds}@$TESTSNAP
	- fi
	+ snapexists ${ds}@$TESTSNAP && \
	+ destroy_dataset ${ds}@$TESTSNAP
	done
	}

	log_assert "'zfs rollback' should fail with bad options,too many arguments," \
	"non-snapshot datasets or missing datasets."
	log_onexit cleanup

	set -A badopts "r" "R" "f" "-F" "-rF" "-RF" "-fF" "-?" "-*" "-blah" "-1" "-2"

	for ds in $TESTPOOL $TESTPOOL/$TESTFS $TESTPOOL/$TESTVOL; do
	log_must zfs snapshot ${ds}@$TESTSNAP
	done

	for ds in $TESTPOOL $TESTPOOL/$TESTFS $TESTPOOL/$TESTVOL; do
	for opt in "" "-r" "-R" "-f" "-rR" "-rf" "-rRf"; do
	log_mustnot eval "zfs rollback $opt $ds >/dev/null 2>&1"
	log_mustnot eval "zfs rollback $opt ${ds}@$TESTSNAP \
	${ds}@$TESTSNAP >/dev/null 2>&1"
	log_mustnot eval "zfs rollback $opt >/dev/null 2>&1"
	# zfs rollback should fail with non-existen snapshot
	log_mustnot eval "zfs rollback $opt ${ds}@nosnap >/dev/null 2>&1"
	done

	for badopt in ${badopts[@]}; do
	log_mustnot eval "zfs rollback $badopt ${ds}@$TESTSNAP \
	>/dev/null 2>&1"
	done
	done

	log_pass "'zfs rollback' fails as expected with illegal arguments."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_rollback/zfs_rollback_common.kshlib b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_rollback/zfs_rollback_common.kshlib
	index b2f4b2b8a3ca..433f240675f3 100644
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_rollback/zfs_rollback_common.kshlib
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_rollback/zfs_rollback_common.kshlib
	@@ -1,321 +1,319 @@
	#
	# 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) 2012, 2016 by Delphix. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/cli_root/zfs_rollback/zfs_rollback.cfg

	# Get file sum
	#
	# $1 full file name
	function getsum #fname
	{
	(( ${#1} == 0 )) && \
	log_fail "Need give file name."
	return $(sum $1 \| awk '{print $1}')
	}

	# Define global variable checksum, get the original file sum.
	#
	origsum=$(getsum /etc/passwd)

	#
	# Setup or recover the test environment. Firstly, copy /etc/passwd to ZFS file
	# system or volume, then make a snapshot or clone. Repeat up to three times.
	#
	# $1 number of snapshot. Note: Currently only support three snapshots.
	# $2 indicate if it is necessary to create clone
	#
	function setup_snap_env
	{
	typeset -i cnt=${1:-3}
	typeset createclone=${2:-"false"}

	if datasetnonexists $FS; then
	log_must zfs create $FS
	log_must zfs set mountpoint=$TESTDIR $FS
	fi
	# Volume can't be created in Local Zone.
	if datasetnonexists $VOL && is_global_zone; then
	log_must zfs create -V $VOLSIZE $VOL
	block_device_wait
	fi

	# Make sure $VOL is volume
	typeset type=$(get_prop type $VOL)
	if datasetexists $VOL && \
	[[ $type == 'volume' ]]; then
	#
	# At the first time, Make a UFS file system in volume and
	# mount it. Otherwise, only check if this ufs\|ext file system
	# was mounted.
	#
	log_must new_fs $ZVOL_DEVDIR/$VOL

	[[ ! -d $TESTDIR1 ]] && log_must mkdir $TESTDIR1

	# Make sure the ufs\|ext filesystem hasn't been mounted,
	# then mount the new ufs\|ext filesystem.
	if ! ismounted $TESTDIR1 $NEWFS_DEFAULT_FS; then
	log_must mount $ZVOL_DEVDIR/$VOL $TESTDIR1
	fi
	fi

	# Separately Create three snapshots for file system & volume
	typeset -i ind=0
	typeset dtst
	for dtst in $FS $VOL; do
	# Volume can be created in Local Zone.
	if [[ $dtst == $VOL ]]; then
	if ! is_global_zone; then
	break
	fi
	fi

	ind=0
	while (( ind < cnt )); do
	case $dtst in
	$FS)
	eval typeset snap=\$FSSNAP$ind
	eval typeset clone=\$FSCLONE$ind
	eval typeset fname=\$TESTDIR/\$TESTFILE$ind
	;;
	$VOL)
	eval typeset snap=\$VOLSNAP$ind
	eval typeset clone=\$VOLCLONE$ind
	eval typeset fname=\$TESTDIR1/\$TESTFILE$ind
	;;
	esac

	if datasetnonexists $snap; then
	log_must cp /etc/passwd $fname
	if is_linux \|\| is_freebsd; then
	log_must sync
	else
	#
	# using 'lockfs -f' to flush the writes
	# to disk before taking a snapshot.
	#
	if [[ $dtst == $VOL ]]; then
	log_must lockfs -f $TESTDIR1
	fi
	fi
	if is_freebsd && [[ $dtst == $VOL ]]; then
	# Though sync does start a fs sync on
	# FreeBSD, it does not wait for it to
	# finish. We can force a blocking sync
	# by updating the fs mount instead.
	# Otherwise, the snapshot might occur
	# with the fs in an unmountable state.
	log_must mount -ur \
	$ZVOL_DEVDIR/$VOL $TESTDIR1
	fi
	log_must zfs snapshot $snap
	if is_freebsd && [[ $dtst == $VOL ]]; then
	log_must mount -uw \
	$ZVOL_DEVDIR/$VOL $TESTDIR1
	fi
	fi
	if [[ $createclone == "true" ]]; then
	if datasetnonexists $clone; then
	log_must zfs clone $snap $clone
	block_device_wait
	fi
	fi
	(( ind += 1 ))
	done
	done
	}

	function setup_clone_env
	{
	setup_snap_env $1 "true"
	}

	#
	# Clean up the test environment
	#
	# $1 number of snapshot Note: Currently only support three snapshots.
	#
	function cleanup_env
	{
	typeset -i cnt=${1:-3}
	typeset -i ind=0
	typeset dtst
	typeset snap

	pkill -x dd

	if ismounted $TESTDIR1 $NEWFS_DEFAULT_FS; then
	log_must umount -f $TESTDIR1
	fi

	[[ -d $TESTDIR ]] && log_must rm -rf $TESTDIR/*
	[[ -d $TESTDIR1 ]] && log_must rm -rf $TESTDIR1/*

	for dtst in $FS $VOL; do
	for snap in $TESTSNAP $TESTSNAP1 $TESTSNAP2; do
	- if snapexists $dtst@$snap; then
	- log_must zfs destroy -Rf $dtst@$snap
	- fi
	+ snapexists $dtst@$snap && destroy_dataset $dtst@$snap -Rf
	done
	done

	# Restore original test environment
	if datasetnonexists $FS ; then
	log_must zfs create $FS
	fi
	if datasetnonexists $VOL ; then
	if is_global_zone ; then
	log_must zfs create -V $VOLSIZE $VOL
	else
	log_must zfs create $VOL
	fi
	fi
	}

	#
	# check if the specified files have specified status.
	#
	# $1 expected status
	# $2-n full file name
	# If it is true return 0, else return 1
	#
	function file_status
	{
	(( $# == 0 )) && \
	log_fail "The file name is not defined."

	typeset opt
	case $1 in
	exist) opt="-e" ;;
	nonexist) opt="! -e" ;;
	*) log_fail "Unsupported file status." ;;
	esac

	shift
	while (( $# > 0 )); do
	eval [[ $opt $1 ]] \|\| return 1
	shift
	done

	return 0
	}

	function files_exist
	{
	file_status "exist" $@
	}

	function files_nonexist
	{
	file_status "nonexist" $@
	}

	#
	# According to snapshot check if the file system was recovered to the right
	# point.
	#
	# $1 snapshot. fs@snap or vol@snap
	#
	function check_files
	{
	typeset dtst=$1

	if [[ $(get_prop type $dtst) != snapshot ]]; then
	log_fail "Parameter must be a snapshot."
	fi

	typeset fsvol=${dtst%%@*}
	typeset snap=${dtst##*@}
	if [[ $(get_prop type $fsvol) == "filesystem" ]]; then
	ind=""
	else
	ind="1"
	fi

	eval typeset file0=\$TESTDIR$ind/\$TESTFILE0
	eval typeset file1=\$TESTDIR$ind/\$TESTFILE1
	eval typeset file2=\$TESTDIR$ind/\$TESTFILE2

	case $snap in
	$TESTSNAP2)
	log_must files_exist $file0 $file1 $file2

	typeset sum0=$(getsum $file0)
	typeset sum1=$(getsum $file1)
	typeset sum2=$(getsum $file2)
	if [[ $sum0 != $origsum \|\| \
	$sum1 != $origsum \|\| sum2 != $origsum ]]
	then
	log_fail "After rollback, file sum is changed."
	fi
	;;
	$TESTSNAP1)
	log_must files_exist $file0 $file1
	log_must files_nonexist $file2

	typeset sum0=$(getsum $file0)
	typeset sum1=$(getsum $file1)
	if [[ $sum0 != $origsum \|\| $sum1 != $origsum ]]
	then
	log_fail "After rollback, file sum is changed."
	fi
	;;
	$TESTSNAP)
	log_must files_exist $file0
	log_must files_nonexist $file1 $file2

	typeset sum0=$(getsum $file0)
	if [[ $sum0 != $origsum ]]; then
	log_fail "After rollback, file sum is changed."
	fi
	;;
	esac
	}

	# According to dataset type, write file to different directories.
	#
	# $1 dataset
	#
	function write_mountpoint_dir
	{
	typeset dtst=$1
	typeset dir

	if [[ $dtst == $FS ]]; then
	dir=$TESTDIR
	log_must ismounted $dir
	else
	dir=$TESTDIR1
	log_must ismounted $dir $NEWFS_DEFAULT_FS
	fi
	dd if=/dev/urandom of=$dir/$TESTFILE1 &
	log_must sleep 3
	}
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_send/zfs_send-b.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_send/zfs_send-b.ksh
	index 2105bc4d23e4..f019c2215ecd 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_send/zfs_send-b.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_send/zfs_send-b.ksh
	@@ -1,102 +1,102 @@
	#!/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 2018, 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:
	# 'zfs send -b' should works as expected.
	#
	# STRATEGY:
	# 1. Create a source dataset and set some properties
	# 2. Verify command line options interact with '-b' correctly
	# 3. Send the dataset and its properties to a new "backup" destination
	# 4. Set some properties on the new "backup" dataset
	# 5. Restore the "backup" dataset to a new destination
	# 6. Verify only original (received) properties are sent from "backup"
	#

	verify_runnable "both"

	function cleanup
	{
	for ds in "$SENDFS" "$BACKUP" "$RESTORE"; do
	- datasetexists $ds && log_must zfs destroy -r $ds
	+ datasetexists $ds && destroy_dataset $ds -r
	done
	}

	log_assert "'zfs send -b' should work as expected."
	log_onexit cleanup

	SENDFS="$TESTPOOL/sendfs"
	BACKUP="$TESTPOOL/backup"
	RESTORE="$TESTPOOL/restore"

	# 1. Create a source dataset and set some properties
	log_must zfs create $SENDFS
	log_must zfs snapshot "$SENDFS@s1"
	log_must zfs bookmark "$SENDFS@s1" "$SENDFS#bm"
	log_must zfs snapshot "$SENDFS@s2"
	log_must zfs set "compression=gzip" $SENDFS
	log_must zfs set "org.openzfs:prop=val" $SENDFS
	log_must zfs set "org.openzfs:snapprop=val" "$SENDFS@s1"

	# 2. Verify command line options interact with '-b' correctly
	typeset opts=("" "p" "Rp" "cew" "nv" "D" "DLPRcenpvw")
	for opt in ${opts[@]}; do
	log_must eval "zfs send -b$opt $SENDFS@s1 >$TEST_BASE_DIR/devnull"
	log_must eval "zfs send -b$opt -i $SENDFS@s1 $SENDFS@s2 >$TEST_BASE_DIR/devnull"
	log_must eval "zfs send -b$opt -I $SENDFS@s1 $SENDFS@s2 >$TEST_BASE_DIR/devnull"
	done
	for opt in ${opts[@]}; do
	log_mustnot eval "zfs send -b$opt $SENDFS >$TEST_BASE_DIR/devnull"
	log_mustnot eval "zfs send -b$opt $SENDFS#bm >$TEST_BASE_DIR/devnull"
	done

	# Do 3..6 in a loop to verify various combination of "zfs send" options
	typeset opts=("" "p" "R" "pR" "cew")
	for opt in ${opts[@]}; do
	# 3. Send the dataset and its properties to a new "backup" destination
	# NOTE: only need to send properties (-p) here
	log_must eval "zfs send -p $SENDFS@s1 \| zfs recv $BACKUP"

	# 4. Set some properties on the new "backup" dataset
	# NOTE: override "received" values and set some new properties as well
	log_must zfs set "compression=lz4" $BACKUP
	log_must zfs set "exec=off" $BACKUP
	log_must zfs set "org.openzfs:prop=newval" $BACKUP
	log_must zfs set "org.openzfs:newprop=newval" $BACKUP
	log_must zfs set "org.openzfs:snapprop=newval" "$BACKUP@s1"
	log_must zfs set "org.openzfs:newsnapprop=newval" "$BACKUP@s1"

	# 5. Restore the "backup" dataset to a new destination
	log_must eval "zfs send -b$opt $BACKUP@s1 \| zfs recv $RESTORE"

	# 6. Verify only original (received) properties are sent from "backup"
	log_must eval "check_prop_source $RESTORE compression gzip received"
	log_must eval "check_prop_source $RESTORE org.openzfs:prop val received"
	log_must eval "check_prop_source $RESTORE@s1 org.openzfs:snapprop val received"
	log_must eval "check_prop_source $RESTORE exec on default"
	log_must eval "check_prop_missing $RESTORE org.openzfs:newprop"
	log_must eval "check_prop_missing $RESTORE@s1 org.openzfs:newsnapprop"

	# cleanup
	log_must zfs destroy -r $BACKUP
	log_must zfs destroy -r $RESTORE
	done

	log_pass "'zfs send -b' works as expected."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_send/zfs_send_001_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_send/zfs_send_001_pos.ksh
	index 2c6e3fdd6d2f..b18433085ed5 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_send/zfs_send_001_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_send/zfs_send_001_pos.ksh
	@@ -1,127 +1,125 @@
	#!/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) 2012, 2016 by Delphix. 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' can create valid send streams as expected.
	#
	# STRATEGY:
	# 1. Fill in fs with some data
	# 2. Create a full send streams with the fs
	# 3. Receive the send stream and verify the data integrity
	# 4. Fill in fs with some new data
	# 5. Create an incremental send stream with the fs
	# 6. Receive the incremental send stream and verify the data integrity.
	#

	verify_runnable "both"

	function cleanup
	{
	for snap in $init_snap $inc_snap $rst_snap $rst_inc_snap; do
	- snapexists $snap && \
	- log_must zfs destroy -f $snap
	+ snapexists $snap && destroy_dataset $snap -f
	done

	- datasetexists $rst_root && \
	- log_must zfs destroy -Rf $rst_root
	+ datasetexists $rst_root && destroy_dataset $rst_root -Rf

	for file in $full_bkup $inc_bkup \
	$init_data $inc_data
	do
	[[ -e $file ]] && \
	log_must rm -f $file
	done

	[[ -d $TESTDIR1 ]] && \
	log_must rm -rf $TESTDIR1

	}

	log_assert "Verify 'zfs send' can create valid send streams as expected."
	log_onexit cleanup

	init_snap=$TESTPOOL/$TESTFS@init_snap
	inc_snap=$TESTPOOL/$TESTFS@inc_snap
	full_bkup=$TEST_BASE_DIR/fullbkup.$$
	inc_bkup=$TEST_BASE_DIR/incbkup.$$
	init_data=$TESTDIR/$TESTFILE1
	inc_data=$TESTDIR/$TESTFILE2
	orig_sum=""
	rst_sum=""
	rst_root=$TESTPOOL/rst_ctr
	rst_snap=$rst_root/$TESTFS@init_snap
	rst_inc_snap=$rst_root/$TESTFS@inc_snap
	rst_data=$TESTDIR1/$TESTFS/$TESTFILE1
	rst_inc_data=$TESTDIR1/$TESTFS/$TESTFILE2


	log_note "Verify 'zfs send' can create full send stream."

	#Pre-paration
	log_must zfs create $rst_root
	[[ ! -d $TESTDIR1 ]] && \
	log_must mkdir -p $TESTDIR1
	log_must zfs set mountpoint=$TESTDIR1 $rst_root

	file_write -o create -f $init_data -b $BLOCK_SIZE -c $WRITE_COUNT

	log_must zfs snapshot $init_snap
	zfs send $init_snap > $full_bkup
	(( $? != 0 )) && \
	log_fail "'zfs send' fails to create full send"

	log_note "Verify the send stream is valid to receive."

	log_must zfs receive $rst_snap <$full_bkup
	receive_check $rst_snap ${rst_snap%%@*}
	compare_cksum $init_data $rst_data

	log_note "Verify 'zfs send -i' can create incremental send stream."

	file_write -o create -f $inc_data -b $BLOCK_SIZE -c $WRITE_COUNT -d 0

	log_must zfs snapshot $inc_snap
	zfs send -i $init_snap $inc_snap > $inc_bkup
	(( $? != 0 )) && \
	log_fail "'zfs send -i' fails to create incremental send"

	log_note "Verify the incremental send stream is valid to receive."

	log_must zfs rollback $rst_snap
	log_must zfs receive $rst_inc_snap <$inc_bkup
	receive_check $rst_inc_snap
	compare_cksum $inc_data $rst_inc_data

	log_pass "Verifying 'zfs receive' succeed."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_send/zfs_send_002_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_send/zfs_send_002_pos.ksh
	index 6359bb4f7f22..42bdddd2cc18 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_send/zfs_send_002_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_send/zfs_send_002_pos.ksh
	@@ -1,139 +1,136 @@
	#!/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) 2012, 2016 by Delphix. 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' can generate valid streams with a property setup.
	#
	# STRATEGY:
	# 1. Setup property for filesystem
	# 2. Fill in some data into filesystem
	# 3. Create a full send streams
	# 4. Receive the send stream
	# 5. Verify the receive result
	#

	verify_runnable "both"

	function cleanup
	{
	- snapexists $snap && \
	- log_must zfs destroy $snap
	-
	- datasetexists $ctr && \
	- log_must zfs destroy -r $ctr
	+ snapexists $snap && destroy_dataset $snap
	+ datasetexists $ctr && destroy_dataset $ctr -r

	[[ -e $origfile ]] && \
	log_must rm -f $origfile

	[[ -e $stream ]] && \
	log_must rm -f $stream
	}

	function do_testing # <prop> <prop_value>
	{
	typeset property=$1
	typeset prop_val=$2

	log_must zfs set $property=$prop_val $fs
	file_write -o create -f $origfile -b $BLOCK_SIZE -c $WRITE_COUNT
	log_must zfs snapshot $snap
	zfs send $snap > $stream
	(( $? != 0 )) && \
	log_fail "'zfs send' fails to create send streams."
	zfs receive -d $ctr <$stream
	(( $? != 0 )) && \
	log_fail "'zfs receive' fails to receive send streams."

	#verify receive result
	! datasetexists $rstfs && \
	log_fail "'zfs receive' fails to restore $rstfs"
	! snapexists $rstfssnap && \
	log_fail "'zfs receive' fails to restore $rstfssnap"
	if [[ ! -e $rstfile ]] \|\| [[ ! -e $rstsnapfile ]]; then
	log_fail " Data lost after receiving stream"
	fi

	compare_cksum $origfile $rstfile
	compare_cksum $origsnapfile $rstsnapfile

	#Destroy datasets and stream for next testing
	log_must zfs destroy $snap
	if is_global_zone ; then
	log_must zfs destroy -r $rstfs
	else
	log_must zfs destroy -r $ds_path
	fi
	log_must rm -f $stream
	}

	log_assert "Verify 'zfs send' generates valid streams with a property setup"
	log_onexit cleanup

	fs=$TESTPOOL/$TESTFS
	snap=$fs@$TESTSNAP
	ctr=$TESTPOOL/$TESTCTR
	if is_global_zone; then
	rstfs=$ctr/$TESTFS
	else
	ds_path=$ctr/${ZONE_CTR}0
	rstfs=$ds_path/$TESTFS
	fi
	rstfssnap=$rstfs@$TESTSNAP
	snapdir=".zfs/snapshot/$TESTSNAP"
	origfile=$TESTDIR/$TESTFILE1
	rstfile=/$rstfs/$TESTFILE1
	origsnapfile=$TESTDIR/$snapdir/$TESTFILE1
	rstsnapfile=/$rstfs/$snapdir/$TESTFILE1
	stream=$TEST_BASE_DIR/streamfile.$$

	set -A props "compression" "checksum" "recordsize"
	set -A propval "on lzjb" "on fletcher2 fletcher4 sha256" \
	"512 1k 4k 8k 16k 32k 64k 128k"

	#Create a dataset to receive the send stream
	log_must zfs create $ctr

	typeset -i i=0
	while (( i < ${#props[*]} ))
	do
	for value in ${propval[i]}
	do
	do_testing ${props[i]} $value
	done

	(( i = i + 1 ))
	done

	log_pass "'zfs send' generates streams with a property setup as expected."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_send/zfs_send_003_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_send/zfs_send_003_pos.ksh
	index 0b55254f75d6..caa84886fa12 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_send/zfs_send_003_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_send/zfs_send_003_pos.ksh
	@@ -1,69 +1,69 @@
	#!/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.
	#

	. $STF_SUITE/include/libtest.shlib

	#
	# DESCRIPTION:
	# 'zfs send -i' can deal with abbreviated snapshot name.
	#
	# STRATEGY:
	# 1. Create pool, fs and two snapshots.
	# 2. Make sure 'zfs send -i' support abbreviated snapshot name.
	#

	verify_runnable "both"

	function cleanup
	{
	- datasetexists $snap1 && log_must zfs destroy $snap1
	- datasetexists $snap2 && log_must zfs destroy $snap2
	+ datasetexists $snap1 && destroy_dataset $snap1
	+ datasetexists $snap2 && destroy_dataset $snap2
	}

	log_assert "'zfs send -i' can deal with abbreviated snapshot name."
	log_onexit cleanup

	snap1=$TESTPOOL/$TESTFS@snap1; snap2=$TESTPOOL/$TESTFS@snap2

	set -A args "$snap1 $snap2" \
	"${snap1##@} $snap2" "@${snap1##@} $snap2"

	log_must zfs snapshot $snap1
	log_must zfs snapshot $snap2

	typeset -i i=0
	while (( i < ${#args[*]} )); do
	log_must eval "zfs send -i ${args[i]} >$TEST_BASE_DIR/devnull"

	(( i += 1 ))
	done

	log_pass "'zfs send -i' deal with abbreviated snapshot name passed."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_send/zfs_send_004_neg.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_send/zfs_send_004_neg.ksh
	index dfa9fc251d6b..af10e3a11faf 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_send/zfs_send_004_neg.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_send/zfs_send_004_neg.ksh
	@@ -1,109 +1,108 @@
	#!/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) 2016 by Delphix. All rights reserved.
	#

	. $STF_SUITE/tests/functional/cli_root/cli_common.kshlib

	#
	# DESCRIPTION:
	# Verify 'zfs send' fails with malformed parameters.
	#
	# STRATEGY:
	# 1. Define malformed parameters in array
	# 2. Feed the parameters to 'zfs send'
	# 3. Verify the result
	#

	verify_runnable "both"

	function cleanup
	{
	typeset snap f

	for snap in $snap1 $snap2 $snap3; do
	- snapexists $snap && \
	- log_must zfs destroy -f $snap
	+ snapexists $snap && destroy_dataset $snap -f
	done

	for f in $tmpfile1 $tmpfile2; do
	if [[ -e $f ]]; then
	rm -f $f
	fi
	done
	}

	fs=$TESTPOOL/$TESTFS
	snap1=$fs@snap1
	snap2=$fs@snap2
	snap3=$fs@snap3

	set -A badargs \
	"" "$TESTPOOL" "$TESTFS" "$fs" "$fs@nonexistent_snap" "?" \
	"$snap1/blah" "$snap1@blah" "-i" "-x" "-i $fs" \
	"-x $snap1 $snap2" "-i $snap1" \
	"-i $snap2 $snap1" "$snap1 $snap2" "-i $snap1 $snap2 $snap3" \
	"-ii $snap1 $snap2" "-iii $snap1 $snap2" " -i $snap2 $snap1/blah" \
	"-i $snap2/blah $snap1" \
	"-i $snap2/blah $snap1/blah" \
	"-i $snap1 blah@blah" \
	"-i blah@blah $snap1" \
	"-i $snap1 ${snap2##@}" "-i $snap1 @${snap2##@}" \
	"-i ${snap1##@} ${snap2##@}" "-i @${snap1##@} @${snap2##@}" \
	"-i ${snap1##@} $snap2/blah" "-i @${snap1##@} $snap2/blah" \
	"-i @@${snap1##*@} $snap2" "-i $snap1 -i $snap1 $snap2" \
	"-i snap1 snap2" "-i $snap1 snap2" \
	"-i $snap1 $snap2 -i $snap1 $snap2" \
	"-i snap1 $snap2 -i snap1 $snap2"

	log_assert "Verify that invalid parameters to 'zfs send' are caught."
	log_onexit cleanup

	log_must zfs snapshot $snap1
	tmpfile1=$TESTDIR/testfile1.$$
	log_must touch $tmpfile1
	log_must zfs snapshot $snap2
	tmpfile2=$TESTDIR/testfile2.$$
	log_must touch $tmpfile2
	log_must zfs snapshot $snap3

	typeset -i i=0
	while (( i < ${#badargs[*]} ))
	do
	log_mustnot eval "zfs send ${badargs[i]} >$TEST_BASE_DIR/devnull"

	(( i = i + 1 ))
	done

	#Testing zfs send fails by send backup stream to terminal
	for arg in "$snap1" "-i $snap1 $snap2"; do
	log_mustnot eval "zfs send $arg >/dev/console"
	done

	log_pass "Invalid parameters to 'zfs send' are caught as expected."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_send/zfs_send_005_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_send/zfs_send_005_pos.ksh
	index c9e37cbbad8e..c4ab7a6212bc 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_send/zfs_send_005_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_send/zfs_send_005_pos.ksh
	@@ -1,66 +1,66 @@
	#!/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) 2012, 2016 by Delphix. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib

	#
	# DESCRIPTION:
	# 'zfs send -R' can send from read-only imported pool. It needs to
	# detect that the pool is read-only and not try to place holds on
	# datasets being sent.
	#
	# STRATEGY:
	# 1. Create a recursive snapshot on the whole pool.
	# 2. 'zfs send -R' the recursive snapshots.
	#

	verify_runnable "both"

	function cleanup
	{
	poolexists $TESTPOOL && log_must_busy zpool export $TESTPOOL
	log_must zpool import $TESTPOOL

	datasetexists $TESTPOOL@snap && \
	- log_must zfs destroy -r $TESTPOOL@snap
	+ destroy_dataset $TESTPOOL@snap -r
	}

	log_assert "'zfs send -R' can send from read-only pools"
	log_onexit cleanup

	log_must zfs snapshot -r $TESTPOOL@snap

	log_must zpool export $TESTPOOL
	log_must zpool import -o readonly=on $TESTPOOL

	log_must eval "zfs send -R $TESTPOOL@snap >$TEST_BASE_DIR/devnull"

	log_pass "'zfs send -R' can send from read-only pools"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_send/zfs_send_encrypted.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_send/zfs_send_encrypted.ksh
	index 1e63b29ade1f..a4c332d47dfc 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_send/zfs_send_encrypted.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_send/zfs_send_encrypted.ksh
	@@ -1,76 +1,76 @@
	#!/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) 2017, Datto, Inc. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib

	#
	# DESCRIPTION:
	# ZFS should perform unencrypted sends of encrypted datasets, unless the '-p'
	# or '-R' options are specified.
	#
	# STRATEGY:
	# 1. Create an encrypted dataset
	# 6. Create a child encryption root
	# 2. Snapshot the dataset
	# 3. Attempt a send
	# 4. Attempt a send with properties
	# 5. Attempt a replication send
	# 7. Unmount the parent and unload its key
	# 8. Attempt a send of the parent dataset
	# 9. Attempt a send of the child encryption root
	#

	verify_runnable "both"

	function cleanup
	{
	datasetexists $TESTPOOL/$TESTFS1 && \
	- log_must zfs destroy -r $TESTPOOL/$TESTFS1
	+ destroy_dataset $TESTPOOL/$TESTFS1 -r
	}

	log_onexit cleanup

	log_assert "ZFS should perform unencrypted sends of encrypted datasets, " \
	"unless the '-p' or '-R' options are specified"

	typeset passphrase="password"
	typeset passphrase1="password1"
	typeset snap="$TESTPOOL/$TESTFS1@snap"

	log_must eval "echo $passphrase \| zfs create -o encryption=on" \
	"-o keyformat=passphrase $TESTPOOL/$TESTFS1"

	log_must eval "echo $passphrase1 \| zfs create -o encryption=on" \
	"-o keyformat=passphrase $TESTPOOL/$TESTFS1/child"

	log_must zfs snapshot -r $snap

	log_must eval "zfs send $snap >$TEST_BASE_DIR/devnull"
	log_mustnot eval "zfs send -p $snap >$TEST_BASE_DIR/devnull"
	log_mustnot eval "zfs send -R $snap >$TEST_BASE_DIR/devnull"

	log_must zfs unmount $TESTPOOL/$TESTFS1
	log_must zfs unload-key $TESTPOOL/$TESTFS1

	log_mustnot eval "zfs send $snap >$TEST_BASE_DIR/devnull"
	log_must eval "zfs send $TESTPOOL/$TESTFS1/child@snap >$TEST_BASE_DIR/devnull"

	log_pass "ZFS performs unencrypted sends of encrypted datasets, unless the" \
	"'-p' or '-R' options are specified"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_send/zfs_send_encrypted_unloaded.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_send/zfs_send_encrypted_unloaded.ksh
	index 9d59494fc635..f268f7b38d4d 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_send/zfs_send_encrypted_unloaded.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_send/zfs_send_encrypted_unloaded.ksh
	@@ -1,59 +1,59 @@
	#!/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) 2017, Datto, Inc. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib

	#
	# DESCRIPTION:
	# ZFS should not perform unencrypted sends from encrypted datasets
	# with unloaded keys.
	#
	# STRATEGY:
	# 1. Create an encrypted dataset
	# 2. Snapshot the dataset
	# 3. Unload the dataset key
	# 4. Verify sending the stream fails
	#

	verify_runnable "both"

	function cleanup
	{
	datasetexists $TESTPOOL/$TESTFS1 && \
	- log_must zfs destroy -r $TESTPOOL/$TESTFS1
	+ destroy_dataset $TESTPOOL/$TESTFS1 -r
	}

	log_onexit cleanup

	log_assert "ZFS should not perform unencrypted sends from encrypted datasets" \
	"with unloaded keys."

	typeset passphrase="password"
	typeset snap="$TESTPOOL/$TESTFS1@snap"

	log_must eval "echo $passphrase \| zfs create -o encryption=on" \
	"-o keyformat=passphrase $TESTPOOL/$TESTFS1"
	log_must zfs snapshot $snap
	log_must zfs unmount $TESTPOOL/$TESTFS1
	log_must zfs unload-key $TESTPOOL/$TESTFS1
	log_mustnot eval "zfs send $snap >$TEST_BASE_DIR/devnull"

	log_pass "ZFS does not perform unencrypted sends from encrypted datasets" \
	"with unloaded keys."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_send/zfs_send_raw.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_send/zfs_send_raw.ksh
	index 065eea3ebd86..03c2e78673d8 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_send/zfs_send_raw.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_send/zfs_send_raw.ksh
	@@ -1,79 +1,77 @@
	#!/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) 2017, Datto, Inc. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib

	#
	# DESCRIPTION:
	# ZFS should perform raw sends of datasets.
	#
	# STRATEGY:
	# 1. Create an encrypted dataset
	# 2. Snapshot the default dataset and the encrypted dataset
	# 3. Attempt a raw send of both datasets
	# 4. Attempt a raw send with properties of both datasets
	# 5. Attempt a raw replication send of both datasets
	# 6. Unmount and unload the encrypted dataset key
	# 7. Attempt a raw send of the encrypted dataset
	#

	verify_runnable "both"

	function cleanup
	{
	- snapexists $snap && \
	- log_must zfs destroy $snap
	-
	+ snapexists $snap && destroy_dataset $snap
	datasetexists $TESTPOOL/$TESTFS1 && \
	- log_must zfs destroy -r $TESTPOOL/$TESTFS1
	+ destroy_dataset $TESTPOOL/$TESTFS1 -r
	}

	log_onexit cleanup

	log_assert "ZFS should perform raw sends of datasets"

	typeset passphrase="password"
	typeset snap="$TESTPOOL/$TESTFS@snap"
	typeset snap1="$TESTPOOL/$TESTFS1@snap"

	log_must eval "echo $passphrase \| zfs create -o encryption=on" \
	"-o keyformat=passphrase $TESTPOOL/$TESTFS1"

	log_must zfs snapshot $snap
	log_must zfs snapshot $snap1

	log_must eval "zfs send -w $snap >$TEST_BASE_DIR/devnull"
	log_must eval "zfs send -w $snap1 >$TEST_BASE_DIR/devnull"

	log_note "Verify ZFS can perform raw sends with properties"
	log_must eval "zfs send -wp $snap >$TEST_BASE_DIR/devnull"
	log_must eval "zfs send -wp $snap1 >$TEST_BASE_DIR/devnull"

	log_note "Verify ZFS can perform raw replication sends"
	log_must eval "zfs send -wR $snap >$TEST_BASE_DIR/devnull"
	log_must eval "zfs send -wR $snap1 >$TEST_BASE_DIR/devnull"

	log_note "Verify ZFS can perform a raw send of an encrypted datasets with" \
	"its key unloaded"
	log_must zfs unmount $TESTPOOL/$TESTFS1
	log_must zfs unload-key $TESTPOOL/$TESTFS1
	log_must eval "zfs send -w $snap1 >$TEST_BASE_DIR/devnull"

	log_pass "ZFS performs raw sends of datasets"
	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
	index b367cef9c4a4..2e12d2534412 100755
	--- 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
	@@ -1,77 +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
	+ snapexists $SNAP && destroy_dataset $SNAP -f

	- datasetexists $PARENT && log_must zfs destroy -rf $PARENT
	+ datasetexists $PARENT && destroy_dataset $PARENT -rf

	[[ -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/zfs_send/zfs_send_sparse.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_send/zfs_send_sparse.ksh
	index 4878c06108e4..aeb49afd7fc8 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_send/zfs_send_sparse.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_send/zfs_send_sparse.ksh
	@@ -1,83 +1,83 @@
	#!/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 2017, loli10K <ezomori.nozomu@gmail.com>. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib

	#
	# DESCRIPTION:
	# 'zfs send' should be able to send (big) sparse files correctly.
	#
	# STRATEGY:
	# 1. Create sparse files of various size
	# 2. Snapshot and send these sparse files
	# 3. Verify these files are received correctly and we don't trigger any issue
	# like the one described in https://github.com/openzfs/zfs/pull/6760
	#

	verify_runnable "both"

	function cleanup
	{
	- datasetexists $SENDFS && log_must zfs destroy -r $SENDFS
	- datasetexists $RECVFS && log_must zfs destroy -r $RECVFS
	+ datasetexists $SENDFS && destroy_dataset $SENDFS -r
	+ datasetexists $RECVFS && destroy_dataset $RECVFS -r
	}

	#
	# Write 1 random byte at $offset of "source" file in $sendfs dataset
	# Snapshot and send $sendfs dataset to $recvfs
	# Compare the received file with its source
	#
	function write_compare_files # <sendfs> <recvfs> <offset>
	{
	typeset sendfs="$1"
	typeset recvfs="$2"
	typeset offset="$3"

	# create source filesystem
	log_must zfs create $sendfs
	# write sparse file
	sendfile="$(get_prop mountpoint $sendfs)/data.bin"
	log_must dd if=/dev/urandom of=$sendfile bs=1 count=1 seek=$offset
	# send/receive the file
	log_must zfs snapshot $sendfs@snap
	log_must eval "zfs send $sendfs@snap \| zfs receive $recvfs"
	# compare sparse files
	recvfile="$(get_prop mountpoint $recvfs)/data.bin"
	log_must cmp $sendfile $recvfile $offset $offset
	sendsz=$(stat_size $sendfile)
	recvsz=$(stat_size $recvfile)
	if [[ $sendsz -ne $recvsz ]]; then
	log_fail "$sendfile ($sendsz) and $recvfile ($recvsz) differ."
	fi
	# cleanup
	- log_must zfs destroy -r $sendfs
	- log_must zfs destroy -r $recvfs
	+ destroy_dataset $sendfs -r
	+ destroy_dataset $recvfs -r
	}

	log_assert "'zfs send' should be able to send (big) sparse files correctly."
	log_onexit cleanup

	SENDFS="$TESTPOOL/sendfs"
	RECVFS="$TESTPOOL/recvfs"
	OFF_T_MAX="$(echo '2 ^ 40 * 8 - 1' \| bc)"

	for i in {1..60}; do
	offset=$(echo "2 ^ $i" \| bc)
	[[ is_32bit ]] && [[ $offset -ge $OFF_T_MAX ]] && continue;
	write_compare_files $SENDFS $RECVFS $offset
	done

	log_pass "'zfs send' sends (big) sparse files correctly."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_set/canmount_001_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_set/canmount_001_pos.ksh
	index dd3397f01579..ac5fc8188f5a 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_set/canmount_001_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_set/canmount_001_pos.ksh
	@@ -1,123 +1,122 @@
	#!/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.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/cli_root/zfs_set/zfs_set_common.kshlib

	#
	# DESCRIPTION:
	# Setting valid canmount to filesystem, it is successful.
	# Whatever is set to volume or snapshot, it is failed.
	# 'zfs set canmount=on\|off <fs>'
	#
	# STRATEGY:
	# 1. Setup a pool and create fs, volume, snapshot clone within it.
	# 2. Loop all the valid mountpoint value.
	# 3. Check the return value.
	#

	verify_runnable "both"

	set -A dataset_pos \
	"$TESTPOOL/$TESTFS" "$TESTPOOL/$TESTCTR" "$TESTPOOL/$TESTCLONE"

	if is_global_zone ; then
	set -A dataset_neg \
	"$TESTPOOL/$TESTVOL" "$TESTPOOL/$TESTFS@$TESTSNAP" \
	"$TESTPOOL/$TESTVOL@$TESTSNAP" "$TESTPOOL/$TESTCLONE1"
	else
	set -A dataset_neg \
	"$TESTPOOL/$TESTFS@$TESTSNAP" "$TESTPOOL/$TESTVOL@$TESTSNAP"
	fi


	set -A values "on" "off"

	function cleanup
	{
	- if snapexists $TESTPOOL/$TESTFS@$TESTSNAP ; then
	- log_must zfs destroy -R $TESTPOOL/$TESTFS@$TESTSNAP
	- fi
	- if snapexists $TESTPOOL/$TESTVOL@$TESTSNAP ; then
	- log_must zfs destroy -R $TESTPOOL/$TESTVOL@$TESTSNAP
	- fi
	+ snapexists $TESTPOOL/$TESTFS@$TESTSNAP && \
	+ destroy_dataset $TESTPOOL/$TESTFS@$TESTSNAP -R
	+
	+ snapexists $TESTPOOL/$TESTVOL@$TESTSNAP && \
	+ destroy_dataset $TESTPOOL/$TESTVOL@$TESTSNAP -R

	[[ -n $old_ctr_canmount ]] && \
	log_must zfs set canmount=$old_ctr_canmount $TESTPOOL/$TESTCTR
	[[ -n $old_fs_canmount ]] && \
	log_must zfs set canmount=$old_fs_canmount $TESTPOOL/$TESTFS

	zfs unmount -a > /dev/null 2>&1
	log_must zfs mount -a
	}

	log_assert "Setting a valid property of canmount to file system, it must be successful."
	log_onexit cleanup

	typeset old_fs_canmount="" old_ctr_canmount=""

	old_fs_canmount=$(get_prop canmount $TESTPOOL/$TESTFS)
	[[ $? != 0 ]] && \
	log_fail "Get the $TESTPOOL/$TESTFS canmount error."
	old_ctr_canmount=$(get_prop canmount $TESTPOOL/$TESTCTR)
	[[ $? != 0 ]] && \
	log_fail "Get the $TESTPOOL/$TESTCTR canmount error."

	log_must zfs snapshot $TESTPOOL/$TESTFS@$TESTSNAP
	log_must zfs snapshot $TESTPOOL/$TESTVOL@$TESTSNAP
	log_must zfs clone $TESTPOOL/$TESTFS@$TESTSNAP $TESTPOOL/$TESTCLONE
	log_must zfs clone $TESTPOOL/$TESTVOL@$TESTSNAP $TESTPOOL/$TESTCLONE1

	for dataset in "${dataset_pos[@]}" ; do
	for value in "${values[@]}" ; do
	set_n_check_prop "$value" "canmount" "$dataset"
	if [[ $value == "off" ]]; then
	log_mustnot ismounted $dataset
	log_mustnot zfs mount $dataset
	log_mustnot ismounted $dataset
	else
	if ! ismounted $dataset ; then
	log_must zfs mount $dataset
	fi
	log_must ismounted $dataset
	fi
	done
	done

	for dataset in "${dataset_neg[@]}" ; do
	for value in "${values[@]}" ; do
	set_n_check_prop "$value" "canmount" \
	"$dataset" "false"
	log_mustnot ismounted $dataset
	done
	done

	log_pass "Setting canmount to filesystem pass."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_set/canmount_002_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_set/canmount_002_pos.ksh
	index 1aeee44e044e..55c71f6ca33a 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_set/canmount_002_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_set/canmount_002_pos.ksh
	@@ -1,161 +1,160 @@
	#!/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) 2012, 2016 by Delphix. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/cli_root/zfs_set/zfs_set_common.kshlib

	#
	# DESCRIPTION:
	# Setting valid canmount to filesystem, it is successful.
	# Whatever is set to volume or snapshot, it is failed.
	# 'zfs set canmount=noauto <fs>'
	#
	# STRATEGY:
	# 1. Setup a pool and create fs, volume, snapshot clone within it.
	# 2. Set canmount=noauto for each dataset and check the return value
	# and check if it still can be mounted by mount -a or shared by
	# share -a
	# 3. mount each dataset(except volume) to see if it can be mounted.
	# 4. verify that a mounted dataset can be shared by share -a.
	#

	verify_runnable "both"

	set -A dataset_pos \
	"$TESTPOOL/$TESTFS" "$TESTPOOL/$TESTCTR" "$TESTPOOL/$TESTCLONE"

	if is_global_zone ; then
	set -A dataset_neg \
	"$TESTPOOL/$TESTVOL" "$TESTPOOL/$TESTFS@$TESTSNAP" \
	"$TESTPOOL/$TESTVOL@$TESTSNAP" "$TESTPOOL/$TESTCLONE1"
	else
	set -A dataset_neg \
	"$TESTPOOL/$TESTFS@$TESTSNAP" "$TESTPOOL/$TESTVOL@$TESTSNAP"
	fi

	function cleanup
	{
	i=0
	while (( i < ${#dataset_pos[*]} )); do
	ds=${dataset_pos[i]}
	if datasetexists $ds; then
	log_must zfs set mountpoint=${old_mnt[i]} $ds
	log_must zfs set canmount=${old_canmount[i]} $ds
	fi
	(( i = i + 1 ))
	done

	ds=$TESTPOOL/$TESTCLONE
	if datasetexists $ds; then
	mntp=$(get_prop mountpoint $ds)
	- log_must zfs destroy $ds
	+ destroy_dataset $ds
	if [[ -d $mntp ]]; then
	rm -fr $mntp
	fi
	fi

	- if snapexists $TESTPOOL/$TESTFS@$TESTSNAP ; then
	- log_must zfs destroy -R $TESTPOOL/$TESTFS@$TESTSNAP
	- fi
	- if snapexists $TESTPOOL/$TESTVOL@$TESTSNAP ; then
	- log_must zfs destroy -R $TESTPOOL/$TESTVOL@$TESTSNAP
	- fi
	+ snapexists $TESTPOOL/$TESTFS@$TESTSNAP && \
	+ destroy_dataset $TESTPOOL/$TESTFS@$TESTSNAP -R
	+
	+ snapexists $TESTPOOL/$TESTVOL@$TESTSNAP && \
	+ destroy_dataset $TESTPOOL/$TESTVOL@$TESTSNAP -R

	zfs unmount -a > /dev/null 2>&1
	log_must zfs mount -a

	if [[ -d $tmpmnt ]]; then
	rm -fr $tmpmnt
	fi
	}

	log_assert "Setting canmount=noauto to file system, it must be successful."
	log_onexit cleanup

	set -A old_mnt
	set -A old_canmount
	set -A old_sharenfs
	typeset tmpmnt=/tmpmount$$
	typeset ds

	log_must zfs snapshot $TESTPOOL/$TESTFS@$TESTSNAP
	log_must zfs snapshot $TESTPOOL/$TESTVOL@$TESTSNAP
	log_must zfs clone $TESTPOOL/$TESTFS@$TESTSNAP $TESTPOOL/$TESTCLONE
	log_must zfs clone $TESTPOOL/$TESTVOL@$TESTSNAP $TESTPOOL/$TESTCLONE1

	typeset -i i=0
	while (( i < ${#dataset_pos[*]} )); do
	ds=${dataset_pos[i]}
	old_mnt[i]=$(get_prop mountpoint $ds)
	old_canmount[i]=$(get_prop canmount $ds)
	old_sharenfs[i]=$(get_prop sharenfs $ds)
	(( i = i + 1 ))
	done

	i=0
	while (( i < ${#dataset_pos[*]} )) ; do
	dataset=${dataset_pos[i]}
	set_n_check_prop "noauto" "canmount" "$dataset"
	log_must zfs set mountpoint=$tmpmnt $dataset
	log_must zfs set sharenfs=on $dataset
	if ismounted $dataset; then
	zfs unmount -a > /dev/null 2>&1
	log_must mounted $dataset
	log_must zfs unmount $dataset
	log_must unmounted $dataset
	log_must zfs mount -a
	log_must unmounted $dataset
	log_must zfs share -a
	log_mustnot is_exported $tmpmnt
	else
	log_must zfs mount -a
	log_must unmounted $dataset
	zfs unmount -a > /dev/null 2>&1
	log_must unmounted $dataset
	fi

	log_must zfs mount $dataset
	log_must mounted $dataset
	log_must zfs share -a
	log_must is_exported $tmpmnt

	log_must zfs set sharenfs="${old_sharenfs[i]}" $dataset
	log_must zfs set canmount="${old_canmount[i]}" $dataset
	log_must zfs set mountpoint="${old_mnt[i]}" $dataset
	(( i = i + 1 ))
	done

	for dataset in "${dataset_neg[@]}" ; do
	set_n_check_prop "noauto" "canmount" "$dataset" "false"
	log_mustnot ismounted $dataset
	done

	log_pass "Setting canmount=noauto to filesystem pass."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_set/canmount_003_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_set/canmount_003_pos.ksh
	index a11cfb40884b..e4664d03b43c 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_set/canmount_003_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_set/canmount_003_pos.ksh
	@@ -1,111 +1,110 @@
	#!/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) 2012, 2016 by Delphix. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/cli_root/zfs_set/zfs_set_common.kshlib

	#
	# DESCRIPTION:
	# While canmount=noauto and the dataset is mounted,
	# zfs must not attempt to unmount it.
	#
	# STRATEGY:
	# 1. Setup a pool and create fs, volume, snapshot clone within it.
	# 2. Set canmount=noauto for each dataset and check the return value
	# and check if it still can not be unmounted when the dataset is mounted
	#

	verify_runnable "both"

	set -A dataset_pos "$TESTPOOL/$TESTFS" "$TESTPOOL/$TESTCLONE"

	function cleanup
	{
	i=0
	cd $pwd
	while (( i < ${#dataset_pos[*]} )); do
	ds=${dataset_pos[i]}
	if datasetexists $ds; then
	log_must zfs set mountpoint=${old_mnt[i]} $ds
	log_must zfs set canmount=${old_canmount[i]} $ds
	fi
	(( i = i + 1 ))
	done

	ds=$TESTPOOL/$TESTCLONE
	if datasetexists $ds; then
	mntp=$(get_prop mountpoint $ds)
	- log_must zfs destroy $ds
	+ destroy_dataset $ds
	if [[ -d $mntp ]]; then
	log_must rm -fr $mntp
	fi
	fi

	- if snapexists $TESTPOOL/$TESTFS@$TESTSNAP ; then
	- log_must zfs destroy -R $TESTPOOL/$TESTFS@$TESTSNAP
	- fi
	+ snapexists $TESTPOOL/$TESTFS@$TESTSNAP && \
	+ destroy_dataset $TESTPOOL/$TESTFS@$TESTSNAP -R

	zfs unmount -a > /dev/null 2>&1
	log_must zfs mount -a
	}

	log_assert "While canmount=noauto and the dataset is mounted,"\
	" zfs must not attempt to unmount it"
	log_onexit cleanup

	set -A old_mnt
	set -A old_canmount
	typeset ds
	typeset pwd=$PWD

	log_must zfs snapshot $TESTPOOL/$TESTFS@$TESTSNAP
	log_must zfs clone $TESTPOOL/$TESTFS@$TESTSNAP $TESTPOOL/$TESTCLONE

	typeset -i i=0
	while (( i < ${#dataset_pos[*]} )); do
	ds=${dataset_pos[i]}
	old_mnt[i]=$(get_prop mountpoint $ds)
	old_canmount[i]=$(get_prop canmount $ds)
	(( i = i + 1 ))
	done

	i=0
	while (( i < ${#dataset_pos[*]} )) ; do
	dataset=${dataset_pos[i]}
	if ismounted $dataset; then
	log_must cd ${old_mnt[i]}
	set_n_check_prop "noauto" "canmount" "$dataset"
	log_must mounted $dataset
	fi
	(( i = i + 1 ))
	done

	log_pass "Setting canmount=noauto to filesystem while dataset busy pass."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_set/readonly_001_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_set/readonly_001_pos.ksh
	index 22fb0a77c9ab..4adac420f748 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_set/readonly_001_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_set/readonly_001_pos.ksh
	@@ -1,160 +1,160 @@
	#!/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) 2014, 2016 by Delphix. All rights reserved.
	#

	. $STF_SUITE/tests/functional/cli_root/zfs_set/zfs_set_common.kshlib

	#
	# DESCRIPTION:
	# Setting readonly on a dataset, it should keep the dataset as readonly.
	#
	# STRATEGY:
	# 1. Create pool, then create filesystem and volume within it.
	# 2. Setting readonly to each dataset.
	# 3. Check the return value and make sure it is 0.
	# 4. Verify the stuff under mountpoint is readonly.
	#

	verify_runnable "both"

	function cleanup
	{
	for dataset in $TESTPOOL/$TESTFS $TESTPOOL/$TESTVOL ; do
	snapexists ${dataset}@$TESTSNAP && \
	- log_must zfs destroy -R ${dataset}@$TESTSNAP
	+ destroy_dataset ${dataset}@$TESTSNAP -R
	done
	}

	function initial_dataset # $1 dataset
	{
	typeset dataset=$1

	typeset fstype=$(get_prop type $dataset)

	if [[ $fstype == "filesystem" ]] ; then
	typeset mtpt=$(get_prop mountpoint $dataset)
	log_must touch $mtpt/$TESTFILE0
	log_must mkdir -p $mtpt/$TESTDIR0
	fi
	}


	function cleanup_dataset # $1 dataset
	{
	typeset dataset=$1

	typeset fstype=$(get_prop type $dataset)

	if [[ $fstype == "filesystem" ]] ; then
	typeset mtpt=$(get_prop mountpoint $dataset)
	log_must rm -f $mtpt/$TESTFILE0
	log_must rm -rf $mtpt/$TESTDIR0
	fi
	}

	function verify_readonly # $1 dataset, $2 on\|off
	{
	typeset dataset=$1
	typeset value=$2

	if datasetnonexists $dataset ; then
	log_note "$dataset does not exist!"
	return 1
	fi

	typeset fstype=$(get_prop type $dataset)

	expect="log_must"

	if [[ $2 == "on" ]] ; then
	expect="log_mustnot"
	fi

	case $fstype in
	filesystem)
	typeset mtpt=$(get_prop mountpoint $dataset)
	$expect touch $mtpt/$TESTFILE1
	$expect mkdir -p $mtpt/$TESTDIR1
	$expect eval "echo 'y' \| rm $mtpt/$TESTFILE0"
	$expect rmdir $mtpt/$TESTDIR0

	if [[ $expect == "log_must" ]] ; then
	log_must eval "echo 'y' \| rm $mtpt/$TESTFILE1"
	log_must rmdir $mtpt/$TESTDIR1
	log_must touch $mtpt/$TESTFILE0
	log_must mkdir -p $mtpt/$TESTDIR0
	fi
	;;
	volume)
	$expect eval "new_fs \
	${ZVOL_DEVDIR}/$dataset > /dev/null 2>&1"
	;;
	*)
	;;
	esac

	return 0
	}

	log_onexit cleanup

	log_assert "Setting a valid readonly property on a dataset succeeds."

	typeset all_datasets

	log_must zfs mount -a

	log_must zfs snapshot $TESTPOOL/$TESTFS@$TESTSNAP
	log_must zfs clone $TESTPOOL/$TESTFS@$TESTSNAP $TESTPOOL/$TESTCLONE

	if is_global_zone ; then
	log_must zfs snapshot $TESTPOOL/$TESTVOL@$TESTSNAP
	log_must zfs clone $TESTPOOL/$TESTVOL@$TESTSNAP $TESTPOOL/$TESTCLONE1
	all_datasets="$TESTPOOL $TESTPOOL/$TESTFS $TESTPOOL/$TESTVOL "
	all_datasets+="$TESTPOOL/$TESTCLONE $TESTPOOL/$TESTCLONE1"
	else
	all_datasets="$TESTPOOL $TESTPOOL/$TESTFS $TESTPOOL/$TESTCLONE"
	fi


	for dataset in $all_datasets; do
	for value in on off; do
	set_n_check_prop "off" "readonly" "$dataset"
	initial_dataset $dataset

	set_n_check_prop "$value" "readonly" "$dataset"
	verify_readonly $dataset $value

	set_n_check_prop "off" "readonly" "$dataset"
	cleanup_dataset $dataset
	done
	done

	log_pass "Setting a valid readonly property on a dataset succeeds."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_set/snapdir_001_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_set/snapdir_001_pos.ksh
	index 079fc770a6fe..083a6b1f464f 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_set/snapdir_001_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_set/snapdir_001_pos.ksh
	@@ -1,112 +1,111 @@
	#!/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.
	#

	. $STF_SUITE/tests/functional/cli_root/zfs_set/zfs_set_common.kshlib

	#
	# DESCRIPTION:
	# Setting a valid snapdir on a dataset, it should be successful.
	#
	# STRATEGY:
	# 1. Create pool, then create filesystem and volume within it.
	# 2. Create a snapshot for each dataset.
	# 3. Setting different valid snapdir to each dataset.
	# 4. Check the return value and make sure it is 0.
	# 5. Verify .zfs directory is hidden\|visible according to the snapdir setting.
	#

	verify_runnable "both"

	function cleanup
	{
	for dataset in $all_datasets; do
	- snapexists ${dataset}@snap && \
	- log_must zfs destroy ${dataset}@snap
	+ snapexists ${dataset}@snap && destroy_dataset ${dataset}@snap
	done
	}

	function verify_snapdir_visible # $1 dataset, $2 hidden\|visible
	{
	typeset dataset=$1
	typeset value=$2
	typeset mtpt=$(get_prop mountpoint $dataset)
	typeset name

	for name in `ls -a $mtpt`; do
	if [[ $name == ".zfs" ]]; then
	if [[ $value == "visible" ]]; then
	return 0
	else
	return 1
	fi
	fi
	done

	if [[ $value == "visible" ]]; then
	return 1
	else
	return 0
	fi
	}


	typeset all_datasets

	if is_global_zone ; then
	all_datasets="$TESTPOOL $TESTPOOL/$TESTFS $TESTPOOL/$TESTVOL"
	else
	all_datasets="$TESTPOOL $TESTPOOL/$TESTFS"
	fi

	log_onexit cleanup

	for dataset in $all_datasets; do
	log_must zfs snapshot ${dataset}@snap
	done

	log_assert "Setting a valid snapdir property on a dataset succeeds."

	for dataset in $all_datasets; do
	for value in hidden visible; do
	if [[ $dataset == "$TESTPOOL/$TESTVOL" ]] ; then
	set_n_check_prop "$value" "snapdir" \
	"$dataset" "false"
	else
	set_n_check_prop "$value" "snapdir" \
	"$dataset"
	verify_snapdir_visible $dataset $value
	[[ $? -eq 0 ]] \|\| \
	log_fail "$dataset/.zfs is not $value as expect."
	fi
	done
	done

	log_pass "Setting a valid snapdir property on a dataset succeeds."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_set/user_property_004_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_set/user_property_004_pos.ksh
	index 1d197fa25fbd..bd11ea088333 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_set/user_property_004_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_set/user_property_004_pos.ksh
	@@ -1,101 +1,99 @@
	#!/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.
	#

	. $STF_SUITE/tests/functional/cli_root/zfs_set/zfs_set_common.kshlib

	#
	# DESCRIPTION:
	# User property has no effect to snapshot until 'Snapshot properties' supported.
	#
	# STRATEGY:
	# 1. Verify user properties could be transformed by 'zfs snapshot'
	# 2. Verify user properties could be set upon snapshot.
	#

	verify_runnable "both"

	function cleanup
	{
	for fs in $TESTPOOL/$TESTFS $TESTPOOL/$TESTVOL $TESTPOOL ; do
	typeset fssnap=$fs@snap
	- if datasetexists $fssnap ; then
	- log_must zfs destroy -f $fssnap
	- fi
	+ datasetexists $fssnap && destroy_dataset $fssnap -f
	done
	cleanup_user_prop $TESTPOOL
	}

	function nonexist_user_prop
	{
	typeset user_prop=$1
	typeset dtst=$2

	typeset source=$(get_source $user_prop $dtst)
	typeset value=$(get_prop $user_prop $dtst)
	if [[ $source == '-' && $value == '-' ]]; then
	return 0
	else
	return 1
	fi
	}

	log_assert "User property has no effect to snapshot until 'Snapshot properties' supported."
	log_onexit cleanup

	typeset snap_property=

	zpool upgrade -v \| grep "Snapshot properties" > /dev/null 2>&1
	if (( $? == 0 )) ; then
	snap_property="true"
	fi

	for fs in $TESTPOOL/$TESTFS $TESTPOOL/$TESTVOL $TESTPOOL ; do
	typeset fssnap=$fs@snap
	prop_name=$(valid_user_property 10)
	value=$(user_property_value 16)
	log_must eval "zfs set $prop_name='$value' $fs"
	log_must eval "check_user_prop $fs $prop_name '$value'"

	log_must zfs snapshot $fssnap

	if [[ -n $snap_property ]] ; then
	log_mustnot nonexist_user_prop $prop_name $fssnap

	log_must eval "zfs set $prop_name='$value' $fssnap"
	log_mustnot nonexist_user_prop $prop_name $fssnap
	else
	log_must nonexist_user_prop $prop_name $fssnap
	log_mustnot eval "zfs set $prop_name='$value' $fssnap"
	log_must nonexist_user_prop $prop_name $fssnap
	fi
	done

	log_pass "User properties has effect upon snapshot."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_set/zfs_set_003_neg.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_set/zfs_set_003_neg.ksh
	index 102e8874294f..fd5f7f285f5b 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_set/zfs_set_003_neg.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_set/zfs_set_003_neg.ksh
	@@ -1,77 +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 2009 Sun Microsystems, Inc. All rights reserved.
	# Use is subject to license terms.
	#

	#
	# Copyright (c) 2016 by Delphix. All rights reserved.
	#

	. $STF_SUITE/tests/functional/cli_root/zfs_set/zfs_set_common.kshlib

	#
	# DESCRIPTION:
	# 'zfs set mountpoint/sharenfs' should fail when the mountpoint is invalid
	#
	# STRATEGY:
	# 1. Create invalid scenarios
	# 2. Run zfs set mountpoint/sharenfs with invalid value
	# 3. Verify that zfs set returns expected errors
	#

	verify_runnable "both"

	function cleanup
	{
	if [ -e $badpath ]; then
	rm -f $badpath
	fi
	- if datasetexists $TESTPOOL/foo; then
	- log_must zfs destroy $TESTPOOL/foo
	- fi
	+
	+ datasetexists $TESTPOOL/foo && destroy_dataset $TESTPOOL/foo
	}

	log_assert "'zfs set mountpoint/sharenfs' fails with invalid scenarios"
	log_onexit cleanup

	badpath=$TEST_BASE_DIR/foo1.$$
	touch $badpath
	longpath=$(gen_dataset_name 1030 "abcdefg")

	log_must zfs create -o mountpoint=legacy $TESTPOOL/foo

	# Do the negative testing about "property may be set but unable to remount filesystem"
	log_mustnot eval "zfs set mountpoint=$badpath $TESTPOOL/foo >/dev/null 2>&1"

	# Do the negative testing about "property may be set but unable to reshare filesystem"
	log_mustnot eval "zfs set sharenfs=on $TESTPOOL/foo >/dev/null 2>&1"

	# Do the negative testing about "sharenfs property can not be set to null"
	log_mustnot eval "zfs set sharenfs= $TESTPOOL/foo >/dev/null 2>&1"

	# Do the too long pathname testing (>1024)
	log_mustnot eval "zfs set mountpoint=/$longpath $TESTPOOL/foo >/dev/null 2>&1"

	log_pass "'zfs set mountpoint/sharenfs' fails with invalid scenarios as expected."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_set/zfs_set_keylocation.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_set/zfs_set_keylocation.ksh
	index 0d2e7ab8f298..d8a2fcbdf9b3 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_set/zfs_set_keylocation.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_set/zfs_set_keylocation.ksh
	@@ -1,101 +1,102 @@
	#!/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) 2017 Datto, Inc. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/cli_root/zfs_load-key/zfs_load-key_common.kshlib

	#
	# DESCRIPTION:
	# Unencrypted datasets should only allow keylocation of 'none', encryption
	# roots should only allow keylocation of 'prompt' and file URI, and encrypted
	# child datasets should not be able to change their keylocation.
	#
	# STRATEGY:
	# 1. Verify the key location of the default dataset is 'none'
	# 2. Attempt to change the key location of the default dataset
	# 3. Create an encrypted dataset using a key file
	# 4. Attempt to change the key location of the encrypted dataset to 'none',
	# an invalid location, its current location, and 'prompt'
	# 5. Attempt to reload the encrypted dataset key using the new key location
	# 6. Create a encrypted child dataset
	# 7. Verify the key location of the child dataset is 'none'
	# 8. Attempt to change the key location of the child dataset
	# 9. Verify the key location of the child dataset has not changed
	#

	verify_runnable "both"

	function cleanup
	{
	datasetexists $TESTPOOL/$TESTFS1 && \
	- log_must zfs destroy -r $TESTPOOL/$TESTFS1
	+ destroy_dataset $TESTPOOL/$TESTFS1 -r
	+ cleanup_https
	}
	log_onexit cleanup

	log_assert "Key location can only be 'prompt' or a file path for encryption" \
	"roots, and 'none' for unencrypted volumes"

	log_must eval "echo $PASSPHRASE > /$TESTPOOL/pkey"

	log_must verify_keylocation $TESTPOOL/$TESTFS "none"
	log_must zfs set keylocation=none $TESTPOOL/$TESTFS
	log_mustnot zfs set keylocation=/$TESTPOOL/pkey $TESTPOOL/$TESTFS
	log_mustnot zfs set keylocation=file:///$TESTPOOL/pkey $TESTPOOL/$TESTFS
	log_must verify_keylocation $TESTPOOL/$TESTFS "none"

	log_must zfs create -o encryption=on -o keyformat=passphrase \
	-o keylocation=file:///$TESTPOOL/pkey $TESTPOOL/$TESTFS1

	log_mustnot zfs set keylocation=none $TESTPOOL/$TESTFS1
	if true; then
	log_mustnot zfs set keylocation=/$TESTPOOL/pkey $TESTPOOL/$TESTFS1
	else
	### SOON: ###
	# file:///$TESTPOOL/pkey and /$TESTPOOL/pkey are equivalent on FreeBSD
	# thanks to libfetch. Eventually we want to make the other platforms
	# work this way as well, either by porting libfetch or by other means.
	log_must zfs set keylocation=/$TESTPOOL/pkey $TESTPOOL/$TESTFS1
	fi

	log_must zfs set keylocation=file:///$TESTPOOL/pkey $TESTPOOL/$TESTFS1
	log_must verify_keylocation $TESTPOOL/$TESTFS1 "file:///$TESTPOOL/pkey"

	log_must zfs set keylocation=prompt $TESTPOOL/$TESTFS1
	log_must verify_keylocation $TESTPOOL/$TESTFS1 "prompt"

	log_must zfs unmount $TESTPOOL/$TESTFS1
	log_must zfs unload-key $TESTPOOL/$TESTFS1

	log_must rm /$TESTPOOL/pkey
	log_must eval "echo $PASSPHRASE \| zfs load-key $TESTPOOL/$TESTFS1"
	log_must zfs mount $TESTPOOL/$TESTFS1

	log_must zfs create $TESTPOOL/$TESTFS1/child
	log_must verify_keylocation $TESTPOOL/$TESTFS1/child "none"

	log_mustnot zfs set keylocation=none $TESTPOOL/$TESTFS1/child
	log_mustnot zfs set keylocation=prompt $TESTPOOL/$TESTFS1/child
	log_mustnot zfs set keylocation=file:///$TESTPOOL/pkey $TESTPOOL/$TESTFS1/child
	log_mustnot zfs set keylocation=/$TESTPOOL/pkey $TESTPOOL/$TESTFS1/child

	log_must verify_keylocation $TESTPOOL/$TESTFS1/child "none"

	log_pass "Key location can only be 'prompt' or a file path for encryption" \
	"roots, and 'none' for unencrypted volumes"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_share/zfs_share_001_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_share/zfs_share_001_pos.ksh
	index fefeb1b1cbd5..6d4396aa1912 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_share/zfs_share_001_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_share/zfs_share_001_pos.ksh
	@@ -1,160 +1,159 @@
	#!/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, 2020 by Delphix. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib

	#
	# DESCRIPTION:
	# Verify that 'zfs set sharenfs' and 'zfs share' shares a given dataset.
	#
	# STRATEGY:
	# 1. Invoke 'zfs set sharenfs'.
	# 2. Verify that the file system is shared.
	# 3. Invoke 'zfs share'.
	# 4. Verify that the file system is shared.
	# 5. Verify that a shared filesystem cannot be shared again.
	# 6. Verify that share -a succeeds.
	#

	verify_runnable "global"

	set -A fs \
	"$TESTDIR1" "$TESTPOOL/$TESTCTR/$TESTFS1" \
	"$TESTDIR2" "$TESTPOOL/$TESTFS-clone" \
	"$TESTDIR" "$TESTPOOL/$TESTFS"

	function cleanup
	{
	typeset -i i=0
	while (( i < ${#fs[*]} )); do
	log_must zfs set sharenfs=off ${fs[((i+1))]}
	unshare_fs ${fs[i]}

	((i = i + 2))
	done

	if mounted $TESTPOOL/$TESTFS-clone; then
	log_must zfs unmount $TESTDIR2
	fi

	datasetexists $TESTPOOL/$TESTFS-clone && \
	- log_must zfs destroy -f $TESTPOOL/$TESTFS-clone
	+ destroy_dataset $TESTPOOL/$TESTFS-clone -f

	- if snapexists "$TESTPOOL/$TESTFS@snapshot"; then
	- log_must zfs destroy -f $TESTPOOL/$TESTFS@snapshot
	- fi
	+ snapexists "$TESTPOOL/$TESTFS@snapshot" && \
	+ destroy_dataset $TESTPOOL/$TESTFS@snapshot -f

	log_must zfs share -a
	}


	#
	# Main test routine.
	#
	# Given a mountpoint and file system this routine will attempt
	# share the mountpoint and then verify it has been shared.
	#
	function test_share # mntp filesystem
	{
	typeset mntp=$1
	typeset filesystem=$2

	not_shared $mntp \|\| \
	log_fail "File system $filesystem is already shared."

	log_must zfs set sharenfs=on $filesystem
	is_shared $mntp \|\| \
	log_fail "File system $filesystem is not shared (set sharenfs)."

	#
	# Verify 'zfs share' works as well.
	#
	log_must zfs unshare $filesystem
	is_shared $mntp && \
	log_fail "File system $filesystem is still shared."

	log_must zfs share $filesystem
	is_shared $mntp \|\| \
	log_fail "file system $filesystem is not shared (zfs share)."

	log_note "Sharing a shared file system fails."
	log_mustnot zfs share $filesystem
	}

	log_assert "Verify that 'zfs share' succeeds as root."
	log_onexit cleanup

	log_must zfs snapshot $TESTPOOL/$TESTFS@snapshot
	log_must zfs clone $TESTPOOL/$TESTFS@snapshot $TESTPOOL/$TESTFS-clone
	log_must zfs set mountpoint=$TESTDIR2 $TESTPOOL/$TESTFS-clone

	typeset -i i=0
	while (( i < ${#fs[*]} )); do
	test_share ${fs[i]} ${fs[((i + 1))]}

	((i = i + 2))
	done

	log_note "Verify 'zfs share -a' succeeds."

	#
	# Unshare each of the file systems.
	#
	i=0
	while (( i < ${#fs[*]} )); do
	unshare_fs ${fs[i]}

	((i = i + 2))
	done

	#
	# Try a zfs share -a and verify all file systems are shared.
	#
	log_must zfs share -a

	#
	# We need to unset __ZFS_POOL_EXCLUDE so that we include all file systems
	# in the os-specific zfs exports file. This will be reset by the next test.
	#
	unset __ZFS_POOL_EXCLUDE

	i=0
	while (( i < ${#fs[*]} )); do
	is_shared ${fs[i]} \|\| \
	log_fail "File system ${fs[i]} is not shared (share -a)"

	is_exported ${fs[i]} \|\| \
	log_fail "File system ${fs[i]} is not exported (share -a)"

	((i = i + 2))
	done

	log_pass "'zfs share [ -a ] <filesystem>' succeeds as root."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_share/zfs_share_004_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_share/zfs_share_004_pos.ksh
	index baa5f4e41695..6c48875f5268 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_share/zfs_share_004_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_share/zfs_share_004_pos.ksh
	@@ -1,96 +1,95 @@
	#!/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) 2012, 2016 by Delphix. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/cli_root/zfs_share/zfs_share.cfg

	#
	# DESCRIPTION:
	# Verify that a file system and its snapshot are shared.
	#
	# STRATEGY:
	# 1. Create a file system
	# 2. Set the sharenfs property on the file system
	# 3. Create a snapshot
	# 4. Verify that both are shared.
	#

	verify_runnable "global"

	function cleanup
	{
	- if snapexists $TESTPOOL/$TESTFS@snapshot; then
	- log_must zfs destroy $TESTPOOL/$TESTFS@snapshot
	- fi
	+ snapexists $TESTPOOL/$TESTFS@snapshot && \
	+ destroy_dataset $TESTPOOL/$TESTFS@snapshot

	log_must zfs set sharenfs=off $TESTPOOL/$TESTFS
	log_must unshare_fs $TESTPOOL/$TESTFS
	}

	#
	# Main test routine.
	#
	# Given a mountpoint and file system this routine will attempt
	# share the mountpoint and then verify a snapshot of the mounpoint
	# is also shared.
	#
	function test_snap_share # mntp filesystem
	{
	typeset mntp=$1
	typeset filesystem=$2

	not_shared $mntp \|\| \
	log_fail "File system $filesystem is already shared."

	log_must zfs set sharenfs=on $filesystem
	is_shared $mntp \|\| \
	log_fail "File system $filesystem is not shared (set sharenfs)."

	log_must ls -l $mntp/$SNAPROOT/snapshot
	#
	# Verify 'zfs share' works as well.
	#
	log_must zfs unshare $filesystem
	log_must zfs share $filesystem

	is_shared $mntp \|\| \
	log_fail "file system $filesystem is not shared (zfs share)."

	log_must ls -l $mntp/$SNAPROOT/snapshot
	}

	log_assert "Verify that a file system and its snapshot are shared."
	log_onexit cleanup

	log_must zfs snapshot $TESTPOOL/$TESTFS@snapshot
	test_snap_share $TESTDIR $TESTPOOL/$TESTFS

	log_pass "A file system and its snapshot are both shared as expected."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_share/zfs_share_006_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_share/zfs_share_006_pos.ksh
	index 6b06589b69e2..d5394017d780 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_share/zfs_share_006_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_share/zfs_share_006_pos.ksh
	@@ -1,105 +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 2007 Sun Microsystems, Inc. All rights reserved.
	# Use is subject to license terms.
	#

	#
	# Copyright (c) 2016 by Delphix. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib

	#
	# DESCRIPTION:
	# Verify that a dataset could not be shared but filesystems are shared.
	#
	# STRATEGY:
	# 1. Create a dataset and file system
	# 2. Set the sharenfs property on the dataset
	# 3. Verify that the dataset is unable be shared.
	# 4. Add a new file system to the dataset.
	# 5. Verify that the newly added file system be shared.
	#

	verify_runnable "global"

	function cleanup
	{
	log_must zfs set sharenfs=off $TESTPOOL/$TESTCTR
	if mounted $TESTDIR2; then
	log_must zfs unmount $TESTDIR2
	fi

	datasetexists $TESTPOOL/$TESTCTR/$TESTFS2 && \
	- log_must zfs destroy $TESTPOOL/$TESTCTR/$TESTFS2
	+ destroy_dataset $TESTPOOL/$TESTCTR/$TESTFS2

	typeset fs=""
	for fs in $mntp $TESTDIR1 $TESTDIR2
	do
	log_must unshare_fs $fs
	done
	}

	#
	# Main test routine.
	#
	# Given a mountpoint and a dataset, this routine will set the
	# sharenfs property on the dataset and verify that dataset
	# is unable to be shared but the existing contained file systems
	# could be shared.
	#
	function test_ctr_share # mntp ctr
	{
	typeset mntp=$1
	typeset ctr=$2

	not_shared $mntp \|\| \
	log_fail "Mountpoint: $mntp is already shared."

	log_must zfs set sharenfs=on $ctr

	not_shared $mntp \|\| \
	log_fail "File system $mntp is shared (set sharenfs)."

	#
	# Add a new file system to the dataset and verify it is shared.
	#
	typeset mntp2=$TESTDIR2
	log_must zfs create $ctr/$TESTFS2
	log_must zfs set mountpoint=$mntp2 $ctr/$TESTFS2

	is_shared $mntp2 \|\| \
	log_fail "File system $mntp2 was not shared (set sharenfs)."
	}

	log_assert "Verify that a dataset could not be shared, " \
	"but its sub-filesystems could be shared."
	log_onexit cleanup

	typeset mntp=$(get_prop mountpoint $TESTPOOL/$TESTCTR)
	test_ctr_share $mntp $TESTPOOL/$TESTCTR

	log_pass "A dataset could not be shared, " \
	"but its sub-filesystems could be shared as expect."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_share/zfs_share_011_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_share/zfs_share_011_pos.ksh
	index f75877ee89db..131b039e1cd2 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_share/zfs_share_011_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_share/zfs_share_011_pos.ksh
	@@ -1,89 +1,87 @@
	#!/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) 2016 by Delphix. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib

	#
	# DESCRIPTION:
	# Verify that umount and destroy fail, and do not unshare the shared
	# file system
	#
	# STRATEGY:
	# 1. Share the filesystem via 'zfs set sharenfs'.
	# 2. Try umount failure, and verify that the file system is still shared.
	# 3. Try destroy failure, and verify that the file system is still shared.
	#

	verify_runnable "global"

	function cleanup
	{
	log_must cd $origdir

	log_must zfs set sharenfs=off $TESTPOOL/$TESTFS
	unshare_fs $TESTPOOL/$TESTFS

	- if snapexists "$TESTPOOL/$TESTFS@snapshot"; then
	- log_must zfs destroy -f $TESTPOOL/$TESTFS@snapshot
	- fi
	+ snapexists "$TESTPOOL/$TESTFS@snapshot" && \
	+ destroy_dataset $TESTPOOL/$TESTFS@snapshot -f

	- if datasetexists $TESTPOOL/$TESTFS/fs2 ; then
	- log_must zfs destroy -f $TESTPOOL/$TESTFS/fs2
	- fi
	+ datasetexists $TESTPOOL/$TESTFS/fs2 && \
	+ destroy_dataset $TESTPOOL/$TESTFS/fs2 -f
	}

	log_assert "Verify that umount and destroy fail, and do not unshare the shared" \
	"file system"
	log_onexit cleanup

	typeset origdir=$PWD

	# unmount fails will not unshare the shared filesystem
	log_must zfs set sharenfs=on $TESTPOOL/$TESTFS
	log_must is_shared $TESTDIR
	if cd $TESTDIR ; then
	log_mustnot zfs umount $TESTPOOL/$TESTFS
	else
	log_fail "cd $TESTDIR fails"
	fi
	log_must is_shared $TESTDIR

	# destroy fails will not unshare the shared filesystem
	log_must zfs create $TESTPOOL/$TESTFS/fs2
	if cd $TESTDIR/fs2 ; then
	log_mustnot zfs destroy $TESTPOOL/$TESTFS/fs2
	else
	log_fail "cd $TESTDIR/fs2 fails"
	fi
	log_must is_shared $TESTDIR/fs2

	log_pass "Verify that umount and destroy fail, and do not unshare the shared" \
	"file system"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_share/zfs_share_concurrent_shares.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_share/zfs_share_concurrent_shares.ksh
	index 762436678dcb..dbaaf39b65d4 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_share/zfs_share_concurrent_shares.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_share/zfs_share_concurrent_shares.ksh
	@@ -1,201 +1,201 @@
	#!/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 Delphix. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib

	#
	# DESCRIPTION:
	# Verify that 'zfs set sharenfs=on', 'zfs share', and 'zfs unshare' can
	# run concurrently. The test creates 50 filesystem and 50 threads.
	# Each thread will run through the test strategy in parallel.
	#
	# STRATEGY:
	# 1. Verify that the file system is not shared.
	# 2. Enable the 'sharenfs' property
	# 3. Invoke 'zfs unshare' and verify filesystem is no longer shared
	# 4. Invoke 'zfs share'.
	# 4. Verify that the file system is shared.
	# 5. Verify that a shared filesystem cannot be shared again.
	# 6. Verify that share -a succeeds.
	#

	verify_runnable "global"

	function cleanup
	{
	wait
	for fs in $(seq 0 50)
	do
	log_must zfs set sharenfs=off $TESTPOOL/$TESTFS1/$fs
	log_must zfs set sharenfs=off $TESTPOOL/$TESTFS2/$fs
	log_must zfs set sharenfs=off $TESTPOOL/$TESTFS3/$fs
	unshare_fs $TESTPOOL/$TESTFS1/$fs
	unshare_fs $TESTPOOL/$TESTFS2/$fs
	unshare_fs $TESTPOOL/$TESTFS3/$fs

	if mounted $TESTPOOL/$TESTFS1/$fs; then
	log_must zfs unmount $TESTPOOL/$TESTFS1/$fs
	fi
	if mounted $TESTPOOL/$TESTFS2/$fs; then
	log_must zfs unmount $TESTPOOL/$TESTFS2/$fs
	fi
	if mounted $TESTPOOL/$TESTFS3/$fs; then
	log_must zfs unmount $TESTPOOL/$TESTFS3/$fs
	fi

	datasetexists $TESTPOOL/$TESTFS1/$fs && \
	- log_must zfs destroy -f $TESTPOOL/$TESTFS1/$fs
	+ destroy_dataset $TESTPOOL/$TESTFS1/$fs -f
	datasetexists $TESTPOOL/$TESTFS2/$fs && \
	- log_must zfs destroy -f $TESTPOOL/$TESTFS2/$fs
	+ destroy_dataset $TESTPOOL/$TESTFS2/$fs -f
	datasetexists $TESTPOOL/$TESTFS3/$fs && \
	- log_must zfs destroy -f $TESTPOOL/$TESTFS3/$fs
	+ destroy_dataset $TESTPOOL/$TESTFS3/$fs -f
	done

	log_must zfs share -a
	}

	function create_filesystems
	{
	for fs in $(seq 0 50)
	do
	log_must zfs create -p $TESTPOOL/$TESTFS1/$fs
	log_must zfs create -p $TESTPOOL/$TESTFS2/$fs
	log_must zfs create -p $TESTPOOL/$TESTFS3/$fs
	done
	}

	#
	# Main test routine.
	#
	# Given a file system this routine will attempt
	# share the mountpoint and then verify it has been shared.
	#
	function test_share # filesystem
	{
	typeset filesystem=$1
	typeset mntp=$(get_prop mountpoint $filesystem)

	not_shared $mntp \|\| \
	log_fail "File system $filesystem is already shared."

	zfs set sharenfs=on $filesystem \|\| \
	log_fail "zfs set sharenfs=on $filesystem failed."
	is_shared $mntp \|\| \
	log_fail "File system $filesystem is not shared (set sharenfs)."

	#
	# Verify 'zfs share' works as well.
	#
	zfs unshare $filesystem \|\| \
	log_fail "zfs unshare $filesystem failed."
	is_shared $mntp && \
	log_fail "File system $filesystem is still shared."

	zfs share $filesystem \|\| \
	log_fail "zfs share $filesystem failed."
	is_shared $mntp \|\| \
	log_fail "file system $filesystem is not shared (zfs share)."

	#log_note "Sharing a shared file system fails."
	zfs share $filesystem && \
	log_fail "zfs share $filesystem did not fail"
	return 0
	}

	#
	# Set the main process id so that we know to capture
	# failures from child processes and allow the parent process
	# to report the failure.
	#
	set_main_pid $$
	log_assert "Verify that 'zfs share' succeeds as root."
	log_onexit cleanup

	create_filesystems

	child_pids=()
	for fs in $(seq 0 50)
	do
	test_share $TESTPOOL/$TESTFS1/$fs &
	child_pids+=($!)
	log_note "$TESTPOOL/$TESTFS1/$fs ==> $!"
	test_share $TESTPOOL/$TESTFS2/$fs &
	child_pids+=($!)
	log_note "$TESTPOOL/$TESTFS2/$fs ==> $!"
	test_share $TESTPOOL/$TESTFS3/$fs &
	child_pids+=($!)
	log_note "$TESTPOOL/$TESTFS3/$fs ==> $!"
	done
	wait_for_children "${child_pids[@]}" \|\|
	log_fail "multithreaded share test failed"

	log_note "Verify 'zfs share -a' succeeds."

	#
	# Unshare each of the file systems.
	#
	child_pids=()
	for fs in $(seq 0 50)
	do
	unshare_fs $TESTPOOL/$TESTFS1/$fs &
	child_pids+=($!)
	unshare_fs $TESTPOOL/$TESTFS2/$fs &
	child_pids+=($!)
	unshare_fs $TESTPOOL/$TESTFS3/$fs &
	child_pids+=($!)
	done
	wait_for_children "${child_pids[@]}" \|\|
	log_fail "multithreaded unshare failed"

	#
	# Try a zfs share -a and verify all file systems are shared.
	#
	log_must zfs share -a

	#
	# We need to unset __ZFS_POOL_EXCLUDE so that we include all file systems
	# in the os-specific zfs exports file. This will be reset by the next test.
	#
	unset __ZFS_POOL_EXCLUDE

	for fs in $(seq 0 50)
	do
	is_shared $TESTPOOL/$TESTFS1/$fs \|\| \
	log_fail "File system $TESTPOOL/$TESTFS1/$fs is not shared"
	is_shared $TESTPOOL/$TESTFS2/$fs \|\| \
	log_fail "File system $TESTPOOL/$TESTFS2/$fs is not shared"
	is_shared $TESTPOOL/$TESTFS3/$fs \|\| \
	log_fail "File system $TESTPOOL/$TESTFS3/$fs is not shared"

	is_exported $TESTPOOL/$TESTFS1/$fs \|\| \
	log_fail "File system $TESTPOOL/$TESTFS1/$fs is not exported"
	is_exported $TESTPOOL/$TESTFS2/$fs \|\| \
	log_fail "File system $TESTPOOL/$TESTFS2/$fs is not exported"
	is_exported $TESTPOOL/$TESTFS3/$fs \|\| \
	log_fail "File system $TESTPOOL/$TESTFS3/$fs is not exported"
	done

	log_pass "'zfs share [ -a ] <filesystem>' succeeds as root."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_snapshot/zfs_snapshot_001_neg.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_snapshot/zfs_snapshot_001_neg.ksh
	index 8708d8b62432..2b89af9e5a43 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_snapshot/zfs_snapshot_001_neg.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_snapshot/zfs_snapshot_001_neg.ksh
	@@ -1,117 +1,117 @@
	#!/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) 2012, 2016 by Delphix. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/cli_root/zfs_snapshot/zfs_snapshot.cfg

	#
	# DESCRIPTION:
	# Try each 'zfs snapshot' with inapplicable scenarios to make sure
	# it returns an error. include:
	# * No arguments given.
	# * The argument contains invalid characters for the ZFS namesapec
	# * Leading slash in snapshot name
	# * The argument contains an empty component.
	# * Missing '@' delimiter.
	# * Multiple '@' delimiters in snapshot name.
	# * The snapshot already exist.
	# * Create snapshot upon the pool.
	# (Be removed since pool is treated as filesystem as well)
	# * Create snapshot upon a non-existent filesystem.
	# * Too many arguments.
	#
	# STRATEGY:
	# 1. Create an array of parameters
	# 2. For each parameter in the array, execute the sub-command
	# 3. Verify an error is returned.
	#

	verify_runnable "both"

	set -A args "" \
	"$TESTPOOL/$TESTFS@blah*" "$TESTPOOL/$TESTFS@blah?" \
	"$TESTPOOL/$TESTVOL@blah*" "$TESTPOOL/$TESTVOL@blah?" \
	"/$TESTPOOL/$TESTFS@$TESTSNAP" "/$TESTPOOL/$TESTVOL@$TESTSNAP" \
	"@$TESTSNAP" "$TESTPOOL/$TESTFS@" "$TESTPOOL/$TESTVOL@" \
	"$TESTPOOL//$TESTFS@$TESTSNAP" "$TESTPOOL//$TESTVOL@$TESTSNAP" \
	"$TESTPOOL/$TESTFS/$TESTSNAP" "$TESTPOOL/$TESTVOL/$TESTSNAP" \
	"$TESTPOOL/$TESTFS@$TESTSNAP@$TESTSNAP1" \
	"$TESTPOOL/$TESTVOL@$TESTSNAP@$TESTSNAP1" \
	"$SNAPFS" "$SNAPFS1" \
	"blah/blah@$TESTSNAP"



	function setup_all
	{
	log_note "Create snapshots and mount them..."

	for snap in $SNAPFS $SNAPFS1; do
	if ! snapexists $snap; then
	log_must zfs snapshot $snap
	fi
	done

	return 0
	}

	function cleanup_all
	{
	typeset -i i=0

	while (( i < ${#args[*]} )); do
	for snap in ${args[i]}; do
	- snapexists $snap && log_must zfs destroy -f $snap
	+ snapexists $snap && destroy_dataset $snap -f
	done
	(( i = i + 1 ))
	done

	for mtpt in $SNAPDIR $SNAPDIR1; do
	[[ -d $mtpt ]] && log_must rm -rf $mtpt
	done

	return 0
	}

	log_assert "Badly-formed 'zfs snapshot' with inapplicable scenarios " \
	"should return an error."
	log_onexit cleanup_all

	setup_all

	typeset -i i=0
	while (( i < ${#args[*]} )); do
	log_mustnot zfs snapshot ${args[i]}
	((i = i + 1))
	done

	log_pass "Badly formed 'zfs snapshot' with inapplicable scenarios " \
	"fail as expected."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_snapshot/zfs_snapshot_002_neg.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_snapshot/zfs_snapshot_002_neg.ksh
	index 5d8b6e2750f5..4ae68d411dd0 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_snapshot/zfs_snapshot_002_neg.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_snapshot/zfs_snapshot_002_neg.ksh
	@@ -1,98 +1,97 @@
	#!/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.
	#

	. $STF_SUITE/include/libtest.shlib

	#
	# DESCRIPTION:
	# "zfs snapshot -r" fails with invalid arguments or scenarios.
	# The invalid scenarios may include:
	# (1) The child filesystem already has snapshot with the same name
	# (2) The child volume already has snapshot with the same name
	#
	# STRATEGY:
	# 1. Create an array of invalid arguments
	# 2. Execute 'zfs snapshot -r' with each argument in the array,
	# 3. Verify an error is returned.
	#

	verify_runnable "both"

	function cleanup
	{
	typeset snap

	for snap in $TESTPOOL/$TESTCTR/$TESTFS1@$TESTSNAP \
	$TESTPOOL/$TESTCTR/$TESTVOL@$TESTSNAP;
	do
	- snapexists $snap && \
	- log_must zfs destroy $snap
	+ snapexists $snap && destroy_dataset $snap
	done

	datasetexists $TESTPOOL/$TESTCTR/$TESTVOL && \
	- log_must zfs destroy -rf $TESTPOOL/$TESTCTR/$TESTVOL
	+ destroy_dataset $TESTPOOL/$TESTCTR/$TESTVOL -rf

	}

	log_assert "'zfs snapshot -r' fails with invalid arguments or scenarios. "
	log_onexit cleanup

	set -A args "" \
	"$TESTPOOL/$TESTCTR@$TESTSNAP" "$TESTPOOL/$TESTCTR@blah?" \
	"$TESTPOOL/$TESTCTR@blah*" "@$TESTSNAP" "$TESTPOOL/$TESTCTR@" \
	"$TESTPOOL/$TESTFS/$TESTSNAP" "blah/blah@$TESTSNAP" \
	"$TESTPOOL/$TESTCTR@$TESTSNAP@$TESTSNAP"

	# setup preparations
	log_must zfs snapshot $TESTPOOL/$TESTCTR/$TESTFS1@$TESTSNAP

	# testing
	typeset -i i=0
	while (( i < ${#args[*]} )); do
	log_mustnot zfs snapshot -r ${args[i]}

	((i = i + 1))
	done

	# Testing the invalid scenario: the child volume already has an
	# identical name snapshot, zfs snapshot -r should fail when
	# creating snapshot with -r for the parent
	log_must zfs destroy $TESTPOOL/$TESTCTR/$TESTFS1@$TESTSNAP
	if is_global_zone; then
	log_must zfs create -V $VOLSIZE $TESTPOOL/$TESTCTR/$TESTVOL
	else
	log_must zfs create $TESTPOOL/$TESTCTR/$TESTVOL
	fi
	log_must zfs snapshot $TESTPOOL/$TESTCTR/$TESTVOL@$TESTSNAP

	log_mustnot zfs snapshot -r $TESTPOOL/$TESTCTR@$TESTSNAP

	log_pass "'zfs snapshot -r' fails with invalid arguments or scenarios as expected."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_snapshot/zfs_snapshot_004_neg.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_snapshot/zfs_snapshot_004_neg.ksh
	index 96121f1c136d..16926a48ddc4 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_snapshot/zfs_snapshot_004_neg.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_snapshot/zfs_snapshot_004_neg.ksh
	@@ -1,96 +1,92 @@
	#!/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) 2016 by Delphix. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib

	#
	# DESCRIPTION:
	# Verify recursive snapshotting could not break ZFS.
	#
	# STRATEGY:
	# 1. Create deeply-nested filesystems until it is too long to create snap
	# 2. Verify zfs snapshot -r pool@snap will not break ZFS
	#

	verify_runnable "both"

	function cleanup
	{
	- if datasetexists $initfs ; then
	- log_must zfs destroy -rf $initfs
	- fi
	+ datasetexists $initfs && destroy_dataset $initfs -rf
	}

	log_assert "Verify recursive snapshotting could not break ZFS."
	log_onexit cleanup

	initfs=$TESTPOOL/$TESTFS/$TESTFS
	basefs=$initfs
	typeset -i ret=0 len snaplen
	while ((ret == 0)); do
	zfs create $basefs
	zfs snapshot $basefs@snap1
	ret=$?

	if ((ret != 0)); then
	len=$(echo $basefs\| wc -c)
	log_note "The deeply-nested filesystem len: $len"

	#
	# Make sure there are at lease 2 characters left
	# for snapshot name space, otherwise snapshot name
	# is incorrect
	#
	if ((len >= 255)); then
	- if datasetexists $basefs; then
	- log_must zfs destroy -r $basefs
	- fi
	+ datasetexists $basefs && destroy_dataset $basefs -r
	basefs=${basefs%/*}
	len=$(echo $basefs\| wc -c)
	fi
	break
	fi

	basefs=$basefs/$TESTFS
	done

	# Make snapshot name is longer than the max length
	((snaplen = 256 - len + 10))
	snap=$(gen_dataset_name $snaplen "s")
	log_mustnot zfs snapshot -r $TESTPOOL@$snap

	log_must datasetnonexists $TESTPOOL@$snap
	while [[ $basefs != $TESTPOOL ]]; do
	log_must datasetnonexists $basefs@$snap
	basefs=${basefs%/*}
	done

	log_pass "Verify recursive snapshotting could not break ZFS."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_snapshot/zfs_snapshot_005_neg.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_snapshot/zfs_snapshot_005_neg.ksh
	index d97dc0f82265..c133403ac84a 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_snapshot/zfs_snapshot_005_neg.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_snapshot/zfs_snapshot_005_neg.ksh
	@@ -1,96 +1,92 @@
	#!/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) 2016 by Delphix. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib

	#
	# DESCRIPTION:
	# Long name filesystem with snapshot should not break ZFS.
	#
	# STRATEGY:
	# 1. Create filesystem and snapshot.
	# 2. When the snapshot length is 256, rename the filesystem.
	# 3. Verify it does not break ZFS
	#

	verify_runnable "both"

	function cleanup
	{
	- if datasetexists $initfs ; then
	- log_must zfs destroy -rf $initfs
	- fi
	+ datasetexists $initfs && destroy_dataset $initfs -rf
	}

	log_assert "Verify long name filesystem with snapshot should not break ZFS."
	log_onexit cleanup

	initfs=$TESTPOOL/$TESTFS/$TESTFS
	basefs=$initfs
	typeset -i ret=0 len snaplen
	while ((ret == 0)); do
	zfs create $basefs
	zfs snapshot $basefs@snap1
	ret=$?

	if ((ret != 0)); then
	len=$(echo $basefs \| wc -c)
	log_note "The deeply-nested filesystem len: $len"

	#
	# Make sure there are at lease 2 characters left
	# for snapshot name space, otherwise snapshot name
	# is incorrect
	#
	if ((len >= 255)); then
	- if datasetexists $basefs; then
	- log_must zfs destroy -r $basefs
	- fi
	+ datasetexists $basefs && destroy_dataset $basefs -r
	basefs=${basefs%/*}
	len=$(echo $basefs\| wc -c)
	fi
	break
	fi

	basefs=$basefs/$TESTFS
	done

	# Make snapshot name length match the longest one
	((snaplen = 256 - len - 1)) # 1: @
	snap=$(gen_dataset_name $snaplen "s")
	log_must zfs snapshot $basefs@$snap

	log_mustnot zfs rename $basefs ${basefs}a
	log_mustnot zfs rename $basefs ${basefs}-new
	log_mustnot zfs rename $initfs ${initfs}-new
	log_mustnot zfs rename $TESTPOOL/$TESTFS $TESTPOOL/$TESTFS-new

	log_pass "Verify long name filesystem with snapshot should not break ZFS."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_snapshot/zfs_snapshot_006_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_snapshot/zfs_snapshot_006_pos.ksh
	index 089ebdb97924..6b711286c68d 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_snapshot/zfs_snapshot_006_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_snapshot/zfs_snapshot_006_pos.ksh
	@@ -1,124 +1,122 @@
	#!/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) 2012, 2016 by Delphix. All rights reserved.
	#

	. $STF_SUITE/tests/functional/cli_root/zfs_set/zfs_set_common.kshlib

	#
	# DESCRIPTION:
	# User property could be set via creation time by 'zfs snapshot -o'
	#
	# STRATEGY:
	# 1. Create snapshot and give '-o property=value'
	# 2. Verify the snapshot be created and user property have been set.
	#

	verify_runnable "both"

	function cleanup
	{
	for fs in $TESTPOOL/$TESTFS $TESTPOOL/$TESTVOL $TESTPOOL ; do
	typeset fssnap=$fs@snap
	- if datasetexists $fssnap ; then
	- log_must zfs destroy -rf $fssnap
	- fi
	+ datasetexists $fssnap && destroy_dataset $fssnap -rf
	done
	cleanup_user_prop $TESTPOOL
	}

	function nonexist_user_prop
	{
	typeset user_prop=$1
	typeset dtst=$2

	typeset source=$(get_source $user_prop $dtst)
	typeset value=$(get_prop $user_prop $dtst)
	if [[ $source == '-' && $value == '-' ]]; then
	return 0
	else
	return 1
	fi
	}

	log_assert "User property could be set upon snapshot via 'zfs snapshot -o'."
	log_onexit cleanup

	typeset snap_property=

	for fs in $TESTPOOL/$TESTFS $TESTPOOL/$TESTVOL $TESTPOOL ; do
	typeset fssnap=$fs@snap
	prop_name=$(valid_user_property 10)
	value=$(user_property_value 16)

	log_must eval "zfs snapshot -o $prop_name='$value' $fssnap"
	log_must snapexists $fssnap
	log_mustnot nonexist_user_prop $prop_name $fssnap

	log_must zfs destroy -f $fssnap

	prop_name2=$(valid_user_property 10)
	value2=$(user_property_value 16)

	log_must eval "zfs snapshot -o $prop_name='$value' -o $prop_name2='$value2' $fssnap"
	log_must snapexists $fssnap
	log_mustnot nonexist_user_prop $prop_name $fssnap
	log_mustnot nonexist_user_prop $prop_name2 $fssnap
	done

	cleanup

	prop_name=$(valid_user_property 10)
	value=$(user_property_value 16)

	log_must eval "zfs snapshot -r -o $prop_name='$value' $TESTPOOL@snap"
	for fs in $TESTPOOL/$TESTFS $TESTPOOL/$TESTVOL $TESTPOOL ; do
	typeset fssnap=$fs@snap
	log_must snapexists $fssnap
	log_mustnot nonexist_user_prop $prop_name $fssnap

	log_must zfs destroy -rf $fssnap
	done

	cleanup

	prop_name2=$(valid_user_property 10)
	value2=$(user_property_value 16)

	log_must eval "zfs snapshot -r -o $prop_name='$value' -o $prop_name2='$value2' $TESTPOOL@snap"
	for fs in $TESTPOOL/$TESTFS $TESTPOOL/$TESTVOL $TESTPOOL ; do
	typeset fssnap=$fs@snap
	log_must snapexists $fssnap
	log_mustnot nonexist_user_prop $prop_name $fssnap
	log_mustnot nonexist_user_prop $prop_name2 $fssnap

	log_must zfs destroy -rf $fssnap
	done

	log_pass "User property could be set upon snapshot via 'zfs snapshot -o'."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_snapshot/zfs_snapshot_007_neg.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_snapshot/zfs_snapshot_007_neg.ksh
	index 9d8c1373f91e..9499dca21e78 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_snapshot/zfs_snapshot_007_neg.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_snapshot/zfs_snapshot_007_neg.ksh
	@@ -1,137 +1,135 @@
	#!/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.
	#

	. $STF_SUITE/tests/functional/cli_root/zfs_set/zfs_set_common.kshlib

	#
	# DESCRIPTION:
	# 'zfs snapshot -o' cannot set properties other than user property
	#
	# STRATEGY:
	# 1. Create snapshot and give '-o property=value' with regular property.
	# 2. Verify the snapshot creation failed.
	#

	verify_runnable "both"

	function cleanup
	{
	for fs in $TESTPOOL/$TESTFS $TESTPOOL/$TESTVOL $TESTPOOL/$TESTCTR $TESTPOOL ; do
	typeset fssnap=$fs@snap
	- if datasetexists $fssnap ; then
	- log_must zfs destroy -rf $fssnap
	- fi
	+ datasetexists $fssnap && destroy_dataset $fssnap -rf
	done
	cleanup_user_prop $TESTPOOL
	}

	function nonexist_user_prop
	{
	typeset user_prop=$1
	typeset dtst=$2

	typeset source=$(get_source $user_prop $dtst)
	typeset value=$(get_prop $user_prop $dtst)
	if [[ $source == '-' && $value == '-' ]]; then
	return 0
	else
	return 1
	fi
	}

	log_assert "'zfs snapshot -o' cannot set properties other than user property."
	log_onexit cleanup

	typeset ro_props="type used available avail creation referenced refer compressratio \
	mounted origin"
	typeset snap_ro_props="volsize recordsize recsize quota reservation reserv mountpoint \
	sharenfs checksum compression compress atime devices exec readonly rdonly \
	setuid"
	if is_freebsd; then
	snap_ro_props+=" jailed"
	else
	snap_ro_props+=" zoned"
	fi

	zfs upgrade -v > /dev/null 2>&1
	if [[ $? -eq 0 ]]; then
	snap_ro_props="$snap_ro_props version"
	fi


	for fs in $TESTPOOL/$TESTFS $TESTPOOL/$TESTVOL $TESTPOOL/$TESTCTR $TESTPOOL ; do
	typeset fssnap=$fs@snap
	prop_name=$(valid_user_property 10)
	value=$(user_property_value 16)

	log_must eval "zfs snapshot -o $prop_name='$value' $fssnap"
	log_must snapexists $fssnap
	log_mustnot nonexist_user_prop $prop_name $fssnap

	log_must zfs destroy -f $fssnap

	prop_name2=$(valid_user_property 10)
	value2=$(user_property_value 16)

	log_must eval "zfs snapshot -o $prop_name='$value' -o $prop_name2='$value2' $fssnap"
	log_must snapexists $fssnap
	log_mustnot nonexist_user_prop $prop_name $fssnap
	log_mustnot nonexist_user_prop $prop_name2 $fssnap

	log_must zfs destroy -f $fssnap
	done

	cleanup

	prop_name=$(valid_user_property 10)
	value=$(user_property_value 16)

	log_must eval "zfs snapshot -r -o $prop_name='$value' $TESTPOOL@snap"
	for fs in $TESTPOOL/$TESTFS $TESTPOOL/$TESTVOL $TESTPOOL/$TESTCTR $TESTPOOL ; do
	typeset fssnap=$fs@snap
	log_must snapexists $fssnap
	log_mustnot nonexist_user_prop $prop_name $fssnap
	done

	cleanup

	prop_name2=$(valid_user_property 10)
	value2=$(user_property_value 16)

	log_must eval "zfs snapshot -r -o $prop_name='$value' -o $prop_name2='$value2' $TESTPOOL@snap"
	for fs in $TESTPOOL/$TESTFS $TESTPOOL/$TESTVOL $TESTPOOL/$TESTCTR $TESTPOOL ; do
	typeset fssnap=$fs@snap
	log_must snapexists $fssnap
	log_mustnot nonexist_user_prop $prop_name $fssnap
	log_mustnot nonexist_user_prop $prop_name2 $fssnap
	done

	log_pass "'zfs snapshot -o' cannot set properties other than user property."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_snapshot/zfs_snapshot_009_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_snapshot/zfs_snapshot_009_pos.ksh
	index a20fcc4ce224..6fedba9e5b27 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_snapshot/zfs_snapshot_009_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_snapshot/zfs_snapshot_009_pos.ksh
	@@ -1,132 +1,131 @@
	#!/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.
	# Copyright (c) 2020 by Datto Inc. All rights reserved.
	#

	#
	# DESCRIPTION
	# verify 'zfs snapshot <list of snapshots>' works correctly
	#
	# STRATEGY
	# 1. Create multiple datasets
	# 2. Create multiple snapshots with a list of valid and invalid
	# snapshot names
	# 3. Verify the valid snapshot creation
	# 4. Verify creation of snapshots report the correct numbers by
	# performing a snapshot directory listing

	. $STF_SUITE/include/libtest.shlib

	ZFS_MAX_DATASET_NAME_LEN=256

	function cleanup
	{
	for ds in $datasets; do
	- datasetexists $ds && log_must zfs destroy -r $ds
	+ datasetexists $ds && destroy_dataset $ds -r
	done
	- zfs destroy -r $TESTPOOL/TESTFS4
	- zfs destroy -r $TESTPOOL/TESTFS5
	+ destroy_dataset $TESTPOOL/TESTFS4 -r
	+ destroy_dataset $TESTPOOL/TESTFS5 -r
	}
	datasets="$TESTPOOL/$TESTFS1 $TESTPOOL/$TESTFS2
	$TESTPOOL/$TESTFS3"

	# We subtract 3 for slash (/), at (@), and the terminating nul (\0)
	SNAPSHOT_XXX=$(printf 'x%.0s' \
	{1..$(($ZFS_MAX_DATASET_NAME_LEN - ${#TESTPOOL} - ${#TESTFS1} - 3))})

	invalid_args=("$TESTPOOL/$TESTFS1@now $TESTPOOL/$TESTFS2@now \
	$TESTPOOL/$TESTFS@blah?" "$TESTPOOL/$TESTFS1@blah* \
	$TESTPOOL/$TESTFS2@blah? $TESTPOOL/$TESTFS3@blah%" \
	"$TESTPOOL/$TESTFS1@x$SNAPSHOT_XXX $TESTPOOL/$TESTFS2@300 \
	$TESTPOOL/$TESTFS3@300")

	valid_args=("$TESTPOOL/$TESTFS1@snap $TESTPOOL/$TESTFS2@snap \
	$TESTPOOL/$TESTFS3@snap" "$TESTPOOL/$TESTFS1@$SNAPSHOT_XXX \
	$TESTPOOL/$TESTFS2@2 $TESTPOOL/$TESTFS3@s")

	log_assert "verify zfs supports multiple consistent snapshots"
	log_onexit cleanup
	typeset -i i=1
	test_data=$STF_SUITE/tests/functional/cli_root/zpool_upgrade/blockfiles/*.bz2

	log_note "destroy a list of valid snapshots"
	for ds in $datasets; do
	log_must zfs create $ds
	log_must cp -r $test_data /$ds
	done
	i=0
	while (( i < ${#valid_args[*]} )); do
	log_must zfs snapshot ${valid_args[i]}
	for token in ${valid_args[i]}; do
	- log_must snapexists $token && \
	- log_must zfs destroy $token
	+ snapexists $token && destroy_dataset $token
	done
	((i = i + 1))
	done
	log_note "destroy a list of invalid snapshots"
	i=0
	while (( i < ${#invalid_args[*]} )); do
	log_mustnot zfs snapshot ${invalid_args[i]}
	for token in ${invalid_args[i]}; do
	log_mustnot snapexists $token
	done
	((i = i + 1))
	done
	log_note "verify multiple snapshot transaction group"
	txg_group=$(zdb -Pd $TESTPOOL \| grep snap \| awk '{print $7}')
	for i in 1 2 3; do
	txg_tag=$(echo "$txg_group" \| nawk -v j=$i 'FNR == j {print}')
	[[ $txg_tag != $(echo "$txg_group" \| \
	nawk -v j=$i 'FNR == j {print}') ]] \
	&& log_fail "snapshots belong to different transaction groups"
	done
	log_note "verify snapshot contents"
	for ds in $datasets; do
	diff -q -r /$ds /$ds/.zfs/snapshot/snap > /dev/null 2>&1
	if [[ $? -eq 1 ]]; then
	log_fail "snapshot contents are different from" \
	"the filesystem"
	fi
	done

	# We subtract 3 + 7 + 7 + 1 = 18 for three slashes (/), strlen("TESTFSA") == 7,
	# strlen("TESTFSB") == 7, and the terminating nul (\0)
	DATASET_XXX=$(printf 'x%.0s' \
	{1..$(($ZFS_MAX_DATASET_NAME_LEN - ${#TESTPOOL} - ${#TESTFS3} - 18))})

	log_note "verify multiple snapshot with -r option"
	log_must zfs create $TESTPOOL/TESTFS4
	log_must zfs create -p $TESTPOOL/$TESTFS3/TESTFSA$DATASET_XXX/TESTFSB
	log_mustnot zfs snapshot -r $TESTPOOL/$TESTFS1@snap1 $TESTPOOL/$TESTFS2@snap1 \
	$TESTPOOL/$TESTFS3@snap1 $TESTPOOL/TESTFS4@snap1
	log_must zfs rename $TESTPOOL/$TESTFS3/TESTFSA$DATASET_XXX \
	$TESTPOOL/$TESTFS3/TESTFSA
	log_must zfs snapshot -r $TESTPOOL/$TESTFS1@snap1 $TESTPOOL/$TESTFS2@snap1 \
	$TESTPOOL/$TESTFS3@snap1 $TESTPOOL/TESTFS4@snap1

	MYTEST="TESTFS5"
	ITERATIONS=10
	NUM_SNAPS=5
	for x in {1..$ITERATIONS}; do
	log_must zfs create $TESTPOOL/$MYTEST
	for y in {1..$NUM_SNAPS}; do
	log_must zfs snapshot $TESTPOOL/$MYTEST@$y
	done;
	n=$(ls -1 /$TESTPOOL/$MYTEST/.zfs/snapshot \| wc -l)
	verify_eq $n $NUM_SNAPS "count"
	zfs destroy -r $TESTPOOL/$MYTEST;
	done;

	log_pass "zfs multiple snapshot verified correctly"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_unload-key/zfs_unload-key.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_unload-key/zfs_unload-key.ksh
	index 9e08ac69d4de..55cfb5cade03 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_unload-key/zfs_unload-key.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_unload-key/zfs_unload-key.ksh
	@@ -1,69 +1,69 @@
	#!/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) 2017 Datto, Inc. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/cli_root/zfs_load-key/zfs_load-key_common.kshlib

	#
	# DESCRIPTION:
	# 'zfs unload-key' should only unload the key of an unmounted dataset.
	#
	# STRATEGY:
	# 1. Attempt to unload the default dataset's key
	# 2. Unmount the dataset
	# 3. Attempt to unload the default dataset's key
	# 4. Create an encrypted dataset
	# 5. Attempt to unload the dataset's key
	# 6. Verify the key is loaded
	# 7. Unmount the dataset
	# 8. Attempt to unload the dataset's key
	# 9. Verify the key is not loaded
	# 10. Attempt to unload the dataset's key
	#

	verify_runnable "both"

	function cleanup
	{
	datasetexists $TESTPOOL/$TESTFS1 && \
	- log_must zfs destroy $TESTPOOL/$TESTFS1
	+ destroy_dataset $TESTPOOL/$TESTFS1
	}
	log_onexit cleanup

	log_assert "'zfs unload-key' should unload the key for an unmounted" \
	"encrypted dataset"

	log_mustnot zfs unload-key $TESTPOOL/$TESTFS

	log_must zfs unmount $TESTPOOL/$TESTFS
	log_mustnot zfs unload-key $TESTPOOL/$TESTFS

	log_must eval "echo $PASSPHRASE \| zfs create -o encryption=on" \
	"-o keyformat=passphrase -o keylocation=prompt $TESTPOOL/$TESTFS1"
	log_mustnot zfs unload-key $TESTPOOL/$TESTFS1
	log_must key_available $TESTPOOL/$TESTFS1

	log_must zfs unmount $TESTPOOL/$TESTFS1
	log_must zfs unload-key $TESTPOOL/$TESTFS1
	log_must key_unavailable $TESTPOOL/$TESTFS1

	log_mustnot zfs unload-key $TESTPOOL/$TESTFS1

	log_pass "'zfs unload-key' unloads the key for an unmounted encrypted dataset"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_unload-key/zfs_unload-key_all.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_unload-key/zfs_unload-key_all.ksh
	index ecb98d189424..55da68262019 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_unload-key/zfs_unload-key_all.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_unload-key/zfs_unload-key_all.ksh
	@@ -1,76 +1,75 @@
	#!/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) 2017 Datto, Inc. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/cli_root/zfs_load-key/zfs_load-key_common.kshlib

	#
	# DESCRIPTION:
	# 'zfs unload-key -a' should unload keys for all datasets.
	#
	# STRATEGY:
	# 1. Create an encrypted filesystem, encrypted child dataset, an encrypted
	# zvol, and an encrypted pool
	# 2. Unmount all datasets
	# 3. Attempt to unload all dataset keys
	# 4. Verify each dataset has its key unloaded
	# 5. Attempt to mount each dataset
	#

	verify_runnable "both"

	function cleanup
	{
	- datasetexists $TESTPOOL/$TESTFS1 && \
	- log_must zfs destroy -r $TESTPOOL/$TESTFS1
	- datasetexists $TESTPOOL/zvol && log_must zfs destroy $TESTPOOL/zvol
	+ datasetexists $TESTPOOL/$TESTFS1 && destroy_dataset $TESTPOOL/$TESTFS1 -r
	+ datasetexists $TESTPOOL/zvol && destroy_dataset $TESTPOOL/zvol
	poolexists $TESTPOOL1 && log_must destroy_pool $TESTPOOL1
	}
	log_onexit cleanup

	log_assert "'zfs unload-key -a' should unload keys for all datasets"

	log_must eval "echo $PASSPHRASE1 > /$TESTPOOL/pkey"
	log_must zfs create -o encryption=on -o keyformat=passphrase \
	-o keylocation=file:///$TESTPOOL/pkey $TESTPOOL/$TESTFS1
	log_must zfs create $TESTPOOL/$TESTFS1/child

	log_must zfs create -V 64M -o encryption=on -o keyformat=passphrase \
	-o keylocation=file:///$TESTPOOL/pkey $TESTPOOL/zvol

	typeset DISK2="$(echo $DISKS \| awk '{ print $2}')"
	log_must zpool create -O encryption=on -O keyformat=passphrase \
	-O keylocation=file:///$TESTPOOL/pkey $TESTPOOL1 $DISK2

	log_must zfs unmount $TESTPOOL/$TESTFS1
	log_must zfs unmount $TESTPOOL1

	-log_must zfs unload-key -a
	+log_must_busy zfs unload-key -a

	log_must key_unavailable $TESTPOOL/$TESTFS1
	log_must key_unavailable $TESTPOOL/$TESTFS1/child
	log_must key_unavailable $TESTPOOL/zvol
	log_must key_unavailable $TESTPOOL1

	log_mustnot zfs mount $TESTPOOL
	log_mustnot zfs mount $TESTPOOL/zvol
	log_mustnot zfs mount $TESTPOOL/$TESTFS1

	log_pass "'zfs unload-key -a' unloads keys for all datasets"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_unload-key/zfs_unload-key_recursive.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_unload-key/zfs_unload-key_recursive.ksh
	index 9766b590587f..01c720c04b58 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_unload-key/zfs_unload-key_recursive.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_unload-key/zfs_unload-key_recursive.ksh
	@@ -1,72 +1,72 @@
	#!/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) 2017 Datto, Inc. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/cli_root/zfs_load-key/zfs_load-key_common.kshlib

	#
	# DESCRIPTION:
	# 'zfs unload-key -r' should recursively unload keys.
	#
	# STRATEGY:
	# 1. Create a parent encrypted dataset
	# 2. Create a sibling encrypted dataset
	# 3. Create a child dataset as an encryption root
	# 4. Unmount all datasets
	# 5. Attempt to unload all dataset keys under parent
	# 6. Verify parent and child have their keys unloaded
	# 7. Verify sibling has its key loaded
	# 8. Attempt to mount all datasets
	#

	verify_runnable "both"

	function cleanup
	{
	datasetexists $TESTPOOL/$TESTFS1 && \
	- log_must zfs destroy -r $TESTPOOL/$TESTFS1
	+ destroy_dataset $TESTPOOL/$TESTFS1 -r
	}
	log_onexit cleanup

	log_assert "'zfs unload-key -r' should recursively unload keys"

	log_must eval "echo $PASSPHRASE > /$TESTPOOL/pkey"
	log_must zfs create -o encryption=on -o keyformat=passphrase \
	-o keylocation=file:///$TESTPOOL/pkey $TESTPOOL/$TESTFS1
	log_must zfs create -o keyformat=passphrase \
	-o keylocation=file:///$TESTPOOL/pkey $TESTPOOL/$TESTFS1/child
	log_must eval "echo $PASSPHRASE1 \| zfs create -o encryption=on" \
	"-o keyformat=passphrase -o keylocation=prompt $TESTPOOL/$TESTFS2"

	log_must zfs unmount $TESTPOOL/$TESTFS1
	log_must zfs unmount $TESTPOOL/$TESTFS2

	log_must zfs unload-key -r $TESTPOOL/$TESTFS1

	log_must key_unavailable $TESTPOOL/$TESTFS1
	log_must key_unavailable $TESTPOOL/$TESTFS1/child

	log_must key_available $TESTPOOL/$TESTFS2

	log_mustnot zfs mount $TESTPOOL/$TESTFS1
	log_mustnot zfs mount $TESTPOOL/$TESTFS1/child
	log_must zfs mount $TESTPOOL/$TESTFS2

	log_pass "'zfs unload-key -r' recursively unloads keys"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_unmount/zfs_unmount_001_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_unmount/zfs_unmount_001_pos.ksh
	index fb4d1d937895..6036eb27a062 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_unmount/zfs_unmount_001_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_unmount/zfs_unmount_001_pos.ksh
	@@ -1,117 +1,117 @@
	#!/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.
	#

	. $STF_SUITE/include/libtest.shlib

	#
	# DESCRIPTION:
	# Creates a file system and verifies that it can be unmounted
	# using each of the various unmount options and sub-command
	# variants.
	#
	# STRATEGY:
	# 1. Create and mount a file system as necessary.
	# 2. Umount the file system using the various combinations.
	# - With force option.
	# - Without force option.
	# - Using the unmount sub-command.
	# - Using the umount sub-command.
	#

	verify_runnable "both"


	function cleanup
	{
	mounted $TESTDIR2 && \
	log_must zfs umount -f $TESTDIR2

	datasetexists $TESTPOOL/$TESTFS2 && \
	- log_must zfs destroy $TESTPOOL/$TESTFS2
	+ destroy_dataset $TESTPOOL/$TESTFS2

	[[ -d $TESTDIR2 ]] && \
	log_must rm -rf $TESTDIR2
	}
	function do_unmount
	{
	typeset cmd=$1
	typeset opt=$2
	typeset mnt=$3

	[[ ! -d $TESTDIR2 ]] && \
	log_must mkdir $TESTDIR2

	if ! datasetexists $TESTPOOL/$TESTFS2 ; then
	log_must zfs create $TESTPOOL/$TESTFS2
	log_must zfs set mountpoint=$TESTDIR2 \
	$TESTPOOL/$TESTFS2
	fi

	unmounted $TESTPOOL/$TESTFS2 && \
	log_must zfs mount $TESTPOOL/$TESTFS2

	log_must zfs $cmd $options $mnt

	unmounted "$mnt" \|\| \
	log_fail "Unable to unmount $options $mnt"

	log_note "Successfully unmounted $options $mnt"
	}

	log_onexit cleanup

	set -A cmd "umount" "unmount"
	set -A options "" "-f"
	set -A dev "$TESTPOOL/$TESTFS2" "$TESTDIR2"

	log_assert "Verify the u[n]mount [-f] sub-command."

	typeset -i i=0
	typeset -i j=0
	typeset -i k=0
	while [[ $i -lt ${#cmd[*]} ]]; do
	j=0
	while [[ $j -lt ${#options[*]} ]]; do
	k=0
	while [[ $k -lt ${#dev[*]} ]]; do
	do_unmount "${cmd[i]}" "${options[j]}" \
	"${dev[k]}"

	((k = k + 1))
	done

	((j = j + 1))
	done

	((i = i + 1))
	done

	log_pass "zfs u[n]mount [-f] completed successfully."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_unmount/zfs_unmount_008_neg.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_unmount/zfs_unmount_008_neg.ksh
	index 209497d9c454..e85a0f3cbf68 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_unmount/zfs_unmount_008_neg.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_unmount/zfs_unmount_008_neg.ksh
	@@ -1,146 +1,142 @@
	#!/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.
	#

	. $STF_SUITE/include/libtest.shlib

	#
	# DESCRIPTION:
	# Verify that zfs unmount should fail with bad parameters or scenarios:
	# 1. bad option;
	# 2. too many arguments;
	# 3. null arguments;
	# 4. invalid datasets;
	# 5. invalid mountpoint;
	# 6. already unmounted zfs filesystem;
	# 7. legacy mounted zfs filesystem
	#
	# STRATEGY:
	# 1. Make an array of bad parameters
	# 2. Use zfs unmount to unmount the filesystem
	# 3. Verify that zfs unmount returns error
	#

	verify_runnable "both"

	function cleanup
	{
	for ds in $vol $fs1; do
	- if datasetexists $ds; then
	- log_must zfs destroy -f $ds
	- fi
	+ datasetexists $ds && destroy_dataset $ds -f
	done

	- if snapexists $snap; then
	- log_must zfs destroy $snap
	- fi
	+ snapexists $snap && destroy_dataset $snap

	if [[ -e /tmp/$file ]]; then
	rm -f /tmp/$file
	fi
	if [[ -d /tmp/$dir ]]; then
	rm -rf /tmp/$dir
	fi

	}

	log_assert "zfs unmount fails with bad parameters or scenarios"
	log_onexit cleanup

	fs=$TESTPOOL/$TESTFS
	vol=$TESTPOOL/vol.$$
	snap=$TESTPOOL/$TESTFS@snap.$$
	set -A badargs "A" "-A" "F" "-F" "-" "-x" "-?"

	if ! ismounted $fs; then
	log_must zfs mount $fs
	fi

	log_must zfs snapshot $snap
	if is_global_zone; then
	log_must zfs create -V 10m $vol
	else
	vol=""
	fi

	# Testing bad options
	for arg in ${badargs[@]}; do
	log_mustnot eval "zfs unmount $arg $fs >/dev/null 2>&1"
	done

	# Testing invalid datasets
	for ds in $snap $vol "blah"; do
	for opt in "" "-f"; do
	log_mustnot eval "zfs unmount $opt $ds >/dev/null 2>&1"
	done
	done

	# Testing invalid mountpoint
	dir=foodir.$$
	file=foo.$$
	fs1=$TESTPOOL/fs.$$
	mkdir /tmp/$dir
	touch /tmp/$file
	log_must zfs create -o mountpoint=/tmp/$dir $fs1
	curpath=`dirname $0`
	cd /tmp
	for mpt in "./$dir" "./$file" "/tmp"; do
	for opt in "" "-f"; do
	log_mustnot eval "zfs unmount $opt $mpt >/dev/null 2>&1"
	done
	done
	cd $curpath

	# Testing null argument and too many arguments
	for opt in "" "-f"; do
	log_mustnot eval "zfs unmount $opt >/dev/null 2>&1"
	log_mustnot eval "zfs unmount $opt $fs $fs1 >/dev/null 2>&1"
	done

	# Testing already unmounted filesystem
	log_must zfs unmount $fs1
	for opt in "" "-f"; do
	log_mustnot eval "zfs unmount $opt $fs1 >/dev/null 2>&1"
	log_mustnot eval "zfs unmount /tmp/$dir >/dev/null 2>&1"
	done

	# Testing legacy mounted filesystem
	log_must zfs set mountpoint=legacy $fs1
	if is_linux \|\| is_freebsd; then
	log_must mount -t zfs $fs1 /tmp/$dir
	else
	log_must mount -F zfs $fs1 /tmp/$dir
	fi
	for opt in "" "-f"; do
	log_mustnot eval "zfs unmount $opt $fs1 >/dev/null 2>&1"
	done
	umount /tmp/$dir

	log_pass "zfs unmount fails with bad parameters or scenarios as expected."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_unmount/zfs_unmount_009_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_unmount/zfs_unmount_009_pos.ksh
	index 3575875c2767..814d603db5e0 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_unmount/zfs_unmount_009_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_unmount/zfs_unmount_009_pos.ksh
	@@ -1,142 +1,140 @@
	#!/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.
	#

	. $STF_SUITE/include/libtest.shlib

	#
	# DESCRIPTION:
	# Verify that zfs unmount and destroy in a snapshot directory will not cause error.
	#
	# STRATEGY:
	# 1. Create a file in a zfs filesystem, snapshot it and change directory to snapshot directory
	# 2. Verify that 'zfs unmount -a' will fail and 'zfs unmount -fa' will succeed
	# 3. Verify 'ls' and 'cd /' will succeed
	# 4. 'zfs mount -a' and change directory to snapshot directory again
	# 5. Verify that zfs destroy snapshot will succeed
	# 6. Verify 'ls' and 'cd /' will succeed
	# 7. Create zfs filesystem, create a file, snapshot it and change to snapshot directory
	# 8. Verify that zpool destroy the pool will succeed
	# 9. Verify 'ls' 'cd /' 'zpool list' and etc will succeed
	#

	verify_runnable "both"

	function cleanup
	{
	DISK=${DISKS%% *}

	for fs in $TESTPOOL/$TESTFS $TESTPOOL ; do
	typeset snap=$fs@$TESTSNAP
	- if snapexists $snap; then
	- log_must zfs destroy $snap
	- fi
	+ snapexists $snap && destroy_dataset $snap
	done

	if ! poolexists $TESTPOOL && is_global_zone; then
	log_must zpool create $TESTPOOL $DISK
	fi

	if ! datasetexists $TESTPOOL/$TESTFS; then
	log_must zfs create $TESTPOOL/$TESTFS
	log_must zfs set mountpoint=$TESTDIR $TESTPOOL/$TESTFS
	fi
	}

	function restore_dataset
	{
	if ! datasetexists $TESTPOOL/$TESTFS ; then
	log_must zfs create $TESTPOOL/$TESTFS
	log_must zfs set mountpoint=$TESTDIR $TESTPOOL/$TESTFS
	log_must cd $TESTDIR
	echo hello > world
	log_must zfs snapshot $TESTPOOL/$TESTFS@$TESTSNAP
	log_must cd .zfs/snapshot/$TESTSNAP
	fi
	}


	log_assert "zfs force unmount and destroy in snapshot directory will not cause error."
	log_onexit cleanup

	for fs in $TESTPOOL/$TESTFS $TESTPOOL ; do
	typeset snap=$fs@$TESTSNAP
	typeset mtpt=$(get_prop mountpoint $fs)

	log_must cd $mtpt
	echo hello > world
	log_must zfs snapshot $snap
	log_must cd .zfs/snapshot/$TESTSNAP

	log_mustnot zfs unmount -a
	if is_linux; then
	log_mustnot zfs unmount -fa
	log_must ls
	else
	log_must zfs unmount -fa
	log_mustnot ls
	fi
	log_must cd /

	log_must zfs mount -a
	log_must cd $mtpt
	log_must cd .zfs/snapshot/$TESTSNAP

	if is_global_zone \|\| [[ $fs != $TESTPOOL ]] ; then
	if is_linux; then
	log_mustnot zfs destroy -rf $fs
	log_must ls
	else
	log_must zfs destroy -rf $fs
	log_mustnot ls
	fi
	log_must cd /
	fi

	restore_dataset
	done

	if is_global_zone ; then
	if is_linux; then
	log_mustnot zpool destroy -f $TESTPOOL
	log_must ls
	else
	log_must zpool destroy -f $TESTPOOL
	log_mustnot ls
	fi
	log_must cd /
	fi

	log_must eval zfs list > /dev/null 2>&1
	log_must eval zpool list > /dev/null 2>&1
	log_must eval zpool status > /dev/null 2>&1
	zpool iostat > /dev/null 2>&1

	log_pass "zfs force unmount and destroy in snapshot directory will not cause error."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_unmount/zfs_unmount_unload_keys.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_unmount/zfs_unmount_unload_keys.ksh
	index d6d0a7e9a1b6..c92287ad75e4 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_unmount/zfs_unmount_unload_keys.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_unmount/zfs_unmount_unload_keys.ksh
	@@ -1,79 +1,79 @@
	#!/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 Datto, Inc. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/cli_root/zfs_unmount/zfs_unmount.kshlib
	. $STF_SUITE/tests/functional/cli_root/zfs_load-key/zfs_load-key_common.kshlib

	#
	# DESCRIPTION:
	# "zfs unmount -u" should allow the user to unload their encryption
	# keys while unmounting one or more datasets
	#
	# STRATEGY:
	# 1. Create a hierarchy of encrypted datasets
	# 2. Test that 'zfs unmount -u' unloads keys as it unmounts a dataset
	# 3. Test that 'zfs unmount -u' unloads keys as it unmounts multiple datasets
	# 4. Test that 'zfs unmount -u' returns an error if the key is still in
	# use by a clone.
	#

	verify_runnable "both"

	function cleanup
	{
	datasetexists $TESTPOOL/$TESTFS2 && \
	- log_must zfs destroy -r $TESTPOOL/$TESTFS2
	+ destroy_dataset $TESTPOOL/$TESTFS2 -r
	datasetexists $TESTPOOL/$TESTFS2/newroot && \
	- log_must zfs destroy -r $TESTPOOL/$TESTFS2/newroot
	+ destroy_dataset $TESTPOOL/$TESTFS2/newroot -r
	datasetexists $TESTPOOL/$TESTFS2/child && \
	- log_must zfs destroy -r $TESTPOOL/$TESTFS2/child
	+ destroy_dataset $TESTPOOL/$TESTFS2/child -r

	}
	log_onexit cleanup

	log_assert "'zfs unmount -u' should unload keys for datasets as they are unmounted"
	log_must eval "echo 'password' \| zfs create -o encryption=on -o keyformat=passphrase $TESTPOOL/$TESTFS2"
	log_must eval "echo 'password' \| zfs create -o encryption=on -o keyformat=passphrase $TESTPOOL/$TESTFS2/newroot"
	log_must zfs create $TESTPOOL/$TESTFS2/child

	log_must zfs umount -u $TESTPOOL/$TESTFS2/newroot
	log_must key_unavailable $TESTPOOL/$TESTFS2/newroot
	log_must eval "echo 'password' \| zfs mount -l $TESTPOOL/$TESTFS2/newroot"

	log_must zfs umount -u $TESTPOOL/$TESTFS2
	log_must key_unavailable $TESTPOOL/$TESTFS2
	log_must key_unavailable $TESTPOOL/$TESTFS2/newroot
	log_must key_unavailable $TESTPOOL/$TESTFS2/child
	log_must eval "echo 'password' \| zfs mount -l $TESTPOOL/$TESTFS2/newroot"

	log_must zfs snap $TESTPOOL/$TESTFS2/newroot@1
	log_must zfs clone $TESTPOOL/$TESTFS2/newroot@1 $TESTPOOL/$TESTFS2/clone
	log_mustnot zfs umount -u $TESTPOOL/$TESTFS2/newroot
	log_must key_available $TESTPOOL/$TESTFS2/newroot
	log_must mounted $TESTPOOL/$TESTFS2/newroot

	log_pass "'zfs unmount -u' unloads keys for datasets as they are unmounted"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_unshare/zfs_unshare_001_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_unshare/zfs_unshare_001_pos.ksh
	index ca625bd2278a..ac16fe97b928 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_unshare/zfs_unshare_001_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_unshare/zfs_unshare_001_pos.ksh
	@@ -1,177 +1,174 @@
	#!/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.
	#

	. $STF_SUITE/include/libtest.shlib

	#
	# DESCRIPTION:
	# Verify that 'zfs unshare <filesystem\|mountpoint>' unshares a given shared
	# filesystem.
	#
	# STRATEGY:
	# 1. Share filesystems
	# 2. Invoke 'zfs unshare <filesystem\|mountpoint>' to unshare zfs file system
	# 3. Verify that the file system is unshared
	# 4. Verify that unsharing an unshared file system fails
	# 5. Verify that "zfs unshare -a" succeeds to unshare all zfs file systems.
	#

	verify_runnable "global"

	function cleanup
	{
	typeset -i i=0
	while (( i < ${#mntp_fs[*]} )); do
	log_must zfs set sharenfs=off ${mntp_fs[((i+1))]}

	((i = i + 2))
	done

	if mounted $TESTPOOL/$TESTCLONE; then
	log_must zfs unmount $TESTDIR2
	fi

	[[ -d $TESTDIR2 ]] && \
	log_must rm -rf $TESTDIR2

	- if datasetexists "$TESTPOOL/$TESTCLONE"; then
	- log_must zfs destroy -f $TESTPOOL/$TESTCLONE
	- fi
	+ datasetexists "$TESTPOOL/$TESTCLONE" && \
	+ destroy_dataset $TESTPOOL/$TESTCLONE -f

	- if snapexists "$TESTPOOL/$TESTFS2@snapshot"; then
	- log_must zfs destroy -f $TESTPOOL/$TESTFS2@snapshot
	- fi
	+ snapexists "$TESTPOOL/$TESTFS2@snapshot" && \
	+ destroy_dataset $TESTPOOL/$TESTFS2@snapshot -f

	- if datasetexists "$TESTPOOL/$TESTFS2"; then
	- log_must zfs destroy -f $TESTPOOL/$TESTFS2
	- fi
	+ datasetexists "$TESTPOOL/$TESTFS2" && \
	+ destroy_dataset $TESTPOOL/$TESTFS2 -f
	}

	#
	# Main test routine.
	#
	# Given a mountpoint and file system this routine will attempt
	# unshare the filesystem via <filesystem\|mountpoint> argument
	# and then verify it has been unshared.
	#
	function test_unshare # <mntp> <filesystem>
	{
	typeset mntp=$1
	typeset filesystem=$2
	typeset prop_value

	prop_value=$(get_prop "sharenfs" $filesystem)

	if [[ $prop_value == "off" ]]; then
	not_shared $mntp \|\|
	log_must eval "unshare_nfs $mntp"
	log_must zfs set sharenfs=on $filesystem
	is_shared $mntp \|\| \
	log_fail "'zfs set sharenfs=on' fails to make" \
	"file system $filesystem shared."
	fi

	is_shared $mntp \|\| log_must zfs share $filesystem

	#
	# Verify 'zfs unshare <filesystem>' works as well.
	#
	log_must zfs unshare $filesystem
	not_shared $mntp \|\| log_fail "'zfs unshare <filesystem>' fails"

	log_must zfs share $filesystem

	log_must zfs unshare $mntp
	not_shared $mntp \|\| log_fail "'zfs unshare <mountpoint>' fails"

	log_note "Unsharing an unshared file system fails."
	log_mustnot zfs unshare $filesystem
	log_mustnot zfs unshare $mntp
	}

	set -A mntp_fs \
	"$TESTDIR" "$TESTPOOL/$TESTFS" \
	"$TESTDIR1" "$TESTPOOL/$TESTCTR/$TESTFS1" \
	"$TESTDIR2" "$TESTPOOL/$TESTCLONE"

	log_assert "Verify that 'zfs unshare [-a] <filesystem\|mountpoint>' succeeds as root."
	log_onexit cleanup

	log_must zfs create $TESTPOOL/$TESTFS2
	log_must zfs snapshot $TESTPOOL/$TESTFS2@snapshot
	log_must zfs clone $TESTPOOL/$TESTFS2@snapshot $TESTPOOL/$TESTCLONE
	log_must zfs set mountpoint=$TESTDIR2 $TESTPOOL/$TESTCLONE

	#
	# Invoke 'test_unshare' routine to test 'zfs unshare <filesystem\|mountpoint>'.
	#
	typeset -i i=0
	while (( i < ${#mntp_fs[*]} )); do
	test_unshare ${mntp_fs[i]} ${mntp_fs[((i + 1 ))]}

	((i = i + 2))
	done

	log_note "Verify 'zfs unshare -a' succeeds as root."

	i=0
	typeset sharenfs_val
	while (( i < ${#mntp_fs[*]} )); do
	sharenfs_val=$(get_prop "sharenfs" ${mntp_fs[((i+1))]})
	if [[ $sharenfs_val == "on" ]]; then
	not_shared ${mntp_fs[i]} && \
	log_must zfs share ${mntp_fs[((i+1))]}
	else
	log_must zfs set sharenfs=on ${mntp_fs[((i+1))]}
	is_shared ${mntp_fs[i]} \|\| \
	log_fail "'zfs set sharenfs=on' fails to share filesystem."
	fi

	((i = i + 2))
	done

	#
	# test 'zfs unshare -a '
	#
	log_must zfs unshare -a

	#
	# verify all shared filesystems become unshared
	#
	i=0
	while (( i < ${#mntp_fs[*]} )); do
	not_shared ${mntp_fs[i]} \|\| \
	log_fail "'zfs unshare -a' fails to unshare all shared zfs filesystems."

	((i = i + 2))
	done

	log_pass "'zfs unshare [-a] <filesystem\|mountpoint>' succeeds as root."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_unshare/zfs_unshare_002_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_unshare/zfs_unshare_002_pos.ksh
	index 6a9c72311c74..1ded1b42c7ec 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_unshare/zfs_unshare_002_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_unshare/zfs_unshare_002_pos.ksh
	@@ -1,185 +1,182 @@
	#!/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.
	#

	. $STF_SUITE/include/libtest.shlib

	#
	# DESCRIPTION:
	# Verify that 'zfs unshare [-a] <filesystem\|mountpoint>' is aware of legacy share.
	#
	# STRATEGY:
	# 1. Set 'zfs set sharenfs=off'
	# 2. Use 'share' to share given filesystem
	# 3. Verify that 'zfs unshare <filesystem\|mountpoint>' is aware of legacy share
	# 4. Verify that 'zfs unshare -a' is aware of legacy share.
	#

	verify_runnable "global"

	if is_linux; then
	log_unsupported "zfs set sharenfs=off won't unshare if already off"
	fi

	function cleanup
	{
	typeset -i i=0
	while (( i < ${#mntp_fs[*]} )); do
	is_shared ${mntp_fs[i]} && \
	log_must eval "unshare_nfs ${mntp_fs[i]}"

	((i = i + 2))
	done

	if mounted $TESTPOOL/$TESTCLONE; then
	log_must zfs unmount $TESTDIR2
	fi

	[[ -d $TESTDIR2 ]] && \
	log_must rm -rf $TESTDIR2

	- if datasetexists "$TESTPOOL/$TESTCLONE"; then
	- log_must zfs destroy -f $TESTPOOL/$TESTCLONE
	- fi
	+ datasetexists "$TESTPOOL/$TESTCLONE" && \
	+ destroy_dataset $TESTPOOL/$TESTCLONE -f

	- if snapexists "$TESTPOOL/$TESTFS2@snapshot"; then
	- log_must zfs destroy -f $TESTPOOL/$TESTFS2@snapshot
	- fi
	+ snapexists "$TESTPOOL/$TESTFS2@snapshot" && \
	+ destroy_dataset $TESTPOOL/$TESTFS2@snapshot -f

	- if datasetexists "$TESTPOOL/$TESTFS2"; then
	- log_must zfs destroy -f $TESTPOOL/$TESTFS2
	- fi
	+ datasetexists "$TESTPOOL/$TESTFS2" && \
	+ destroy_dataset $TESTPOOL/$TESTFS2 -f
	}

	#
	# Main test routine.
	#
	# Given a mountpoint and file system this routine will attempt
	# to verify 'zfs unshare' is aware of legacy share.
	#
	function test_legacy_unshare # <mntp> <filesystem>
	{
	typeset mntp=$1
	typeset filesystem=$2

	log_must zfs set sharenfs=off $filesystem
	not_shared $mntp \|\| \
	log_fail "'zfs set sharenfs=off' fails to make ZFS " \
	"filesystem $filesystem unshared."

	log_must eval "share_nfs $mntp"
	is_shared $mntp \|\| \
	log_fail "'share' command fails to share ZFS file system."
	#
	# Verify 'zfs unshare <filesystem>' is aware of legacy share.
	#
	log_mustnot zfs unshare $filesystem
	is_shared $mntp \|\| \
	log_fail "'zfs unshare <filesystem>' fails to be aware" \
	"of legacy share."

	#
	# Verify 'zfs unshare <filesystem>' is aware of legacy share.
	#
	log_mustnot zfs unshare $mntp
	is_shared $mntp \|\| \
	log_fail "'zfs unshare <mountpoint>' fails to be aware" \
	"of legacy share."
	}


	set -A mntp_fs \
	"$TESTDIR" "$TESTPOOL/$TESTFS" \
	"$TESTDIR1" "$TESTPOOL/$TESTCTR/$TESTFS1" \
	"$TESTDIR2" "$TESTPOOL/$TESTCLONE"

	log_assert "Verify that 'zfs unshare [-a]' is aware of legacy share."
	log_onexit cleanup

	log_must zfs create $TESTPOOL/$TESTFS2
	log_must zfs snapshot $TESTPOOL/$TESTFS2@snapshot
	log_must zfs clone $TESTPOOL/$TESTFS2@snapshot $TESTPOOL/$TESTCLONE
	log_must zfs set mountpoint=$TESTDIR2 $TESTPOOL/$TESTCLONE

	#
	# Invoke 'test_legacy_unshare' routine to verify.
	#
	typeset -i i=0
	while (( i < ${#mntp_fs[*]} )); do
	test_legacy_unshare ${mntp_fs[i]} ${mntp_fs[((i + 1 ))]}

	((i = i + 2))
	done


	log_note "Verify 'zfs unshare -a' is aware of legacy share."

	#
	# set the 'sharenfs' property to 'off' for each filesystem
	#
	i=0
	while (( i < ${#mntp_fs[*]} )); do
	log_must zfs set sharenfs=off ${mntp_fs[((i + 1))]}
	not_shared ${mntp_fs[i]} \|\| \
	log_fail "'zfs set sharenfs=off' unshares file system failed."

	((i = i + 2))
	done

	#
	# Share each of the file systems via legacy share.
	#
	i=0
	while (( i < ${#mntp_fs[*]} )); do
	share_nfs ${mntp_fs[i]}
	is_shared ${mntp_fs[i]} \|\| \
	log_fail "'share' shares ZFS filesystem failed."

	((i = i + 2))
	done

	#
	# Verify that 'zfs unshare -a' is aware of legacy share
	#
	log_must zfs unshare -a

	#
	# verify ZFS filesystems are still shared
	#
	i=0
	while (( i < ${#mntp_fs[*]} )); do
	is_shared ${mntp_fs[i]} \|\| \
	log_fail "'zfs unshare -a' fails to be aware of legacy share."

	((i = i + 2))
	done

	log_pass "'zfs unshare [-a]' succeeds to be aware of legacy share."

	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_unshare/zfs_unshare_003_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_unshare/zfs_unshare_003_pos.ksh
	index 66a7e80eb783..6e66deda9bee 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_unshare/zfs_unshare_003_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_unshare/zfs_unshare_003_pos.ksh
	@@ -1,94 +1,93 @@
	#!/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.
	#

	. $STF_SUITE/include/libtest.shlib

	#
	# DESCRIPTION:
	# Verify that a file system and its dependent are unshared when turn off sharenfs
	# property.
	#
	# STRATEGY:
	# 1. Create a file system
	# 2. Set the sharenfs property on the file system
	# 3. Create a snapshot
	# 4. Verify that both are shared
	# 5. Turn off the sharenfs property
	# 6. Verify that both are unshared.
	#

	verify_runnable "global"

	function cleanup
	{
	- if snapexists $TESTPOOL/$TESTFS@snapshot; then
	- log_must zfs destroy $TESTPOOL/$TESTFS@snapshot
	- fi
	+ snapexists $TESTPOOL/$TESTFS@snapshot && \
	+ destroy_dataset $TESTPOOL/$TESTFS@snapshot

	log_must zfs set sharenfs=off $TESTPOOL/$TESTFS
	}

	#
	# Main test routine.
	#
	# Given a mountpoint and file system this routine will attempt
	# unshare the mountpoint and then verify a snapshot of the mounpoint
	# is also unshared.
	#
	function test_snap_unshare # <mntp> <filesystem>
	{
	typeset mntp=$1
	typeset filesystem=$2
	typeset prop_value

	prop_value=$(get_prop "sharenfs" $filesystem)

	if [[ $prop_value == "off" ]]; then
	is_shared $mntp \|\| unshare_nfs $mntp
	log_must zfs set sharenfs=on $filesystem
	fi

	log_must zfs set sharenfs=off $filesystem

	not_shared $mntp \|\| \
	log_fail "File system $filesystem is shared (set sharenfs)."

	not_shared $mntp@snapshot \|\| \
	log_fail "Snapshot $mntpt@snapshot is shared (set sharenfs)."
	}

	log_assert "Verify that a file system and its dependent are unshared."
	log_onexit cleanup

	log_must zfs snapshot $TESTPOOL/$TESTFS@snapshot
	test_snap_unshare $TESTDIR $TESTPOOL/$TESTFS

	log_pass "A file system and its dependent are both unshared as expected."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_unshare/zfs_unshare_007_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_unshare/zfs_unshare_007_pos.ksh
	index a5b29a89618a..36817a092099 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_unshare/zfs_unshare_007_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_unshare/zfs_unshare_007_pos.ksh
	@@ -1,68 +1,67 @@
	#!/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 2016, loli10K. All rights reserved.
	# Copyright (c) 2018 by Delphix. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib

	#
	# DESCRIPTION:
	# Verify that 'zfs destroy' on a shared dataset, will unshare it.
	#
	# STRATEGY:
	# 1. Create and share a dataset with sharenfs.
	# 2. Verify the dataset is shared.
	# 3. Invoke 'zfs destroy' on the dataset.
	# 4. Verify the dataset is not shared.
	#

	verify_runnable "global"

	function cleanup
	{
	- if datasetexists "$TESTPOOL/$TESTFS/shared1"; then
	- log_must zfs destroy -f $TESTPOOL/$TESTFS/shared1
	- fi
	+ datasetexists "$TESTPOOL/$TESTFS/shared1" && \
	+ destroy_dataset $TESTPOOL/$TESTFS/shared1 -f
	}

	log_assert "Verify 'zfs destroy' will unshare the dataset"
	log_onexit cleanup

	# 1. Create and share a dataset with sharenfs.
	log_must zfs create \
	-o sharenfs=on -o mountpoint=$TESTDIR/1 $TESTPOOL/$TESTFS/shared1

	#
	# 2. Verify the datasets is shared.
	#
	log_must is_shared $TESTDIR/1

	# 3. Invoke 'zfs destroy' on the dataset.
	log_must zfs destroy -f $TESTPOOL/$TESTFS/shared1

	# 4. Verify the dataset is not shared.
	log_mustnot is_shared $TESTDIR/1

	log_pass "'zfs destroy' will unshare the dataset."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_upgrade/zfs_upgrade_001_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_upgrade/zfs_upgrade_001_pos.ksh
	index d3ed4a736cc9..ab76461638b9 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_upgrade/zfs_upgrade_001_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_upgrade/zfs_upgrade_001_pos.ksh
	@@ -1,139 +1,135 @@
	#!/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) 2016 by Delphix. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/cli_root/zfs_upgrade/zfs_upgrade.kshlib

	#
	# DESCRIPTION:
	# Executing 'zfs upgrade' command succeeds, it should report
	# the current system version and list all old-version filesystems.
	# If no old-version filesystems be founded, it prints out
	# "All filesystems are formatted with the current version."
	#
	# STRATEGY:
	# 1. Prepare a set of datasets which contain old-version and current version.
	# 2. Execute 'zfs upgrade', verify return 0, and it prints out
	# the current system version and list all old-version filesystems.
	# 3. Remove all old-version filesystems, then execute 'zfs upgrade' again,
	# verify return 0, and get the expected message.
	#

	verify_runnable "both"

	function cleanup
	{
	- if datasetexists $rootfs ; then
	- log_must zfs destroy -Rf $rootfs
	- fi
	+ datasetexists $rootfs && destroy_dataset $rootfs -Rf
	log_must zfs create $rootfs

	for file in $output $oldoutput ; do
	if [[ -f $file ]]; then
	log_must rm -f $file
	fi
	done
	}

	log_assert "Executing 'zfs upgrade' command succeeds."
	log_onexit cleanup

	rootfs=$TESTPOOL/$TESTFS
	typeset output=$TEST_BASE_DIR/zfs-versions.$$
	typeset oldoutput=$TEST_BASE_DIR/zfs-versions-old.$$
	typeset expect_str1="This system is currently running ZFS filesystem version"
	typeset expect_str2="All filesystems are formatted with the current version"
	typeset expect_str3="The following filesystems are out of date, and can be upgraded"
	typeset -i COUNT OLDCOUNT

	zfs upgrade \| nawk '$1 ~ "^[0-9]+$" {print $2}'> $oldoutput
	OLDCOUNT=$( wc -l $oldoutput \| awk '{print $1}' )

	old_datasets=""
	for version in $ZFS_ALL_VERSIONS ; do
	typeset verfs
	eval verfs=\$ZFS_VERSION_$version
	typeset current_fs=$rootfs/$verfs
	typeset current_snap=${current_fs}@snap
	typeset current_clone=$rootfs/clone$verfs
	log_must zfs create -o version=${version} ${current_fs}
	log_must zfs snapshot ${current_snap}
	log_must zfs clone ${current_snap} ${current_clone}

	if (( version != $ZFS_VERSION )); then
	old_datasets="$old_datasets ${current_fs} ${current_clone}"
	fi
	done

	if is_global_zone; then
	log_must zfs create -V 100m $rootfs/$TESTVOL
	fi

	log_must eval 'zfs upgrade > $output 2>&1'

	# we also check that the usage message contains at least a description
	# of the current ZFS version.
	log_must eval 'grep "${expect_str1} $ZFS_VERSION" $output > /dev/null 2>&1'
	zfs upgrade \| nawk '$1 ~ "^[0-9]+$" {print $2}'> $output
	COUNT=$( wc -l $output \| awk '{print $1}' )

	typeset -i i=0
	for fs in ${old_datasets}; do
	log_must grep "^$fs$" $output
	(( i = i + 1 ))
	done

	if (( i != COUNT - OLDCOUNT )); then
	cat $output
	log_fail "More old-version filesystems print out than expect."
	fi

	for fs in $old_datasets ; do
	- if datasetexists $fs ; then
	- log_must zfs destroy -Rf $fs
	- fi
	+ datasetexists $fs && destroy_dataset $fs -Rf
	done

	log_must eval 'zfs upgrade > $output 2>&1'
	log_must eval 'grep "${expect_str1} $ZFS_VERSION" $output > /dev/null 2>&1'
	if (( OLDCOUNT == 0 )); then
	log_must eval 'grep "${expect_str2}" $output > /dev/null 2>&1'
	else
	log_must eval 'grep "${expect_str3}" $output > /dev/null 2>&1'
	fi
	zfs upgrade \| nawk '$1 ~ "^[0-9]+$" {print $2}'> $output
	COUNT=$( wc -l $output \| awk '{print $1}' )

	if (( COUNT != OLDCOUNT )); then
	cat $output
	log_fail "Unexpected old-version filesystems print out."
	fi

	log_pass "Executing 'zfs upgrade' command succeeds."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_upgrade/zfs_upgrade_003_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_upgrade/zfs_upgrade_003_pos.ksh
	index 6df47b450d00..57f74ca28513 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_upgrade/zfs_upgrade_003_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_upgrade/zfs_upgrade_003_pos.ksh
	@@ -1,104 +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 2009 Sun Microsystems, Inc. All rights reserved.
	# Use is subject to license terms.
	#

	#
	# Copyright (c) 2016 by Delphix. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/cli_root/zfs_upgrade/zfs_upgrade.kshlib

	#
	# DESCRIPTION:
	# Executing 'zfs upgrade [-V version] filesystem' command succeeds,
	# it could upgrade a filesystem to specific version or current version.
	#
	# STRATEGY:
	# 1. Prepare a set of datasets which contain old-version and current version.
	# 2. Execute 'zfs upgrade [-V version] filesystem', verify return 0,
	# 3. Verify the filesystem be updated as expected.
	#

	verify_runnable "both"

	function cleanup
	{
	- if datasetexists $rootfs ; then
	- log_must zfs destroy -Rf $rootfs
	- fi
	+ datasetexists $rootfs && destroy_dataset $rootfs -Rf
	log_must zfs create $rootfs
	}

	function setup_datasets
	{
	datasets=""
	for version in $ZFS_ALL_VERSIONS ; do
	typeset verfs
	eval verfs=\$ZFS_VERSION_$version
	typeset current_fs=$rootfs/$verfs
	typeset current_snap=${current_fs}@snap
	typeset current_clone=$rootfs/clone$verfs
	log_must zfs create -o version=${version} ${current_fs}
	log_must zfs snapshot ${current_snap}
	log_must zfs clone ${current_snap} ${current_clone}
	datasets="$datasets ${current_fs} ${current_clone}"
	done
	}

	log_assert "Executing 'zfs upgrade [-V version] filesystem' command succeeds."
	log_onexit cleanup

	rootfs=$TESTPOOL/$TESTFS
	typeset datasets

	typeset newv
	for newv in "" "current" $ZFS_ALL_VERSIONS; do
	setup_datasets
	for fs in $datasets ; do
	typeset -i oldv=$(get_prop version $fs)

	if [[ -n $newv ]]; then
	opt="-V $newv"
	if [[ $newv == current ]]; then
	newv=$ZFS_VERSION
	fi
	else
	newv=$ZFS_VERSION
	fi

	if (( newv >= oldv )); then
	log_must eval 'zfs upgrade $opt $fs > /dev/null 2>&1'
	log_must check_fs_version $fs $newv
	else
	log_mustnot eval 'zfs upgrade $opt $fs > /dev/null 2>&1'
	log_must check_fs_version $fs $oldv
	fi
	done
	cleanup
	done

	log_pass "Executing 'zfs upgrade [-V version] filesystem' command succeeds."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_upgrade/zfs_upgrade_004_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_upgrade/zfs_upgrade_004_pos.ksh
	index e3ff4f4b9073..0b8fef5cd043 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_upgrade/zfs_upgrade_004_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_upgrade/zfs_upgrade_004_pos.ksh
	@@ -1,108 +1,106 @@
	#!/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.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/cli_root/zfs_upgrade/zfs_upgrade.kshlib

	#
	# DESCRIPTION:
	# Executing 'zfs upgrade -r [-V version] filesystem' command succeeds,
	# it upgrade filesystem recursively to specific or current version.
	#
	# STRATEGY:
	# 1. Prepare a set of datasets which contain old-version and current version.
	# 2. Execute 'zfs upgrade -r [-V version] filesystem', verify return 0,
	# 3. Verify the filesystem be updated recursively as expected.
	#

	verify_runnable "both"

	function cleanup
	{
	- if datasetexists $rootfs ; then
	- log_must zfs destroy -Rf $rootfs
	- fi
	+ datasetexists $rootfs && destroy_dataset $rootfs -Rf
	log_must zfs create $rootfs
	}

	function setup_datasets
	{
	datasets=""
	for version in $ZFS_ALL_VERSIONS ; do
	typeset verfs
	eval verfs=\$ZFS_VERSION_$version
	typeset current_fs=$rootfs/$verfs
	typeset current_snap=${current_fs}@snap
	typeset current_clone=$rootfs/clone$verfs
	log_must zfs create -o version=${version} ${current_fs}
	log_must zfs snapshot ${current_snap}
	log_must zfs clone ${current_snap} ${current_clone}

	for subversion in $ZFS_ALL_VERSIONS ; do
	typeset subverfs
	eval subverfs=\$ZFS_VERSION_$subversion
	log_must zfs create -o version=${subversion} \
	${current_fs}/$subverfs
	done
	datasets="$datasets ${current_fs}"
	done
	}

	log_assert "Executing 'zfs upgrade -r [-V version] filesystem' command succeeds."
	log_onexit cleanup

	rootfs=$TESTPOOL/$TESTFS

	typeset datasets

	typeset newv
	for newv in "" "current" $ZFS_VERSION; do
	setup_datasets
	for topfs in $datasets ; do
	if [[ -n $newv ]]; then
	opt="-V $newv"
	if [[ $newv == current ]]; then
	newv=$ZFS_VERSION
	fi
	else
	newv=$ZFS_VERSION
	fi

	log_must eval 'zfs upgrade -r $opt $topfs > /dev/null 2>&1'

	for fs in $(zfs list -rH -t filesystem -o name $topfs) ; do
	log_must check_fs_version $fs $newv
	done
	done
	cleanup
	done

	log_pass "Executing 'zfs upgrade -r [-V version] filesystem' command succeeds."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_upgrade/zfs_upgrade_005_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_upgrade/zfs_upgrade_005_pos.ksh
	index 1a929918bf10..5fcdc6e26852 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_upgrade/zfs_upgrade_005_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_upgrade/zfs_upgrade_005_pos.ksh
	@@ -1,108 +1,106 @@
	#!/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.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/cli_root/zfs_upgrade/zfs_upgrade.kshlib

	#
	# DESCRIPTION:
	# Executing 'zfs upgrade [-V version] -a' command succeeds,
	# it upgrade all filesystems to specific or current version.
	#
	# STRATEGY:
	# 1. Prepare a set of datasets which contain old-version and current version.
	# 2. Execute 'zfs upgrade [-V version] -a', verify return 0,
	# 3. Verify all the filesystems be updated as expected.
	#

	verify_runnable "both"

	function cleanup
	{
	- if datasetexists $rootfs ; then
	- log_must zfs destroy -Rf $rootfs
	- fi
	+ datasetexists $rootfs && destroy_dataset $rootfs -Rf
	log_must zfs create $rootfs
	}

	function setup_datasets
	{
	datasets=""
	for version in $ZFS_ALL_VERSIONS ; do
	typeset verfs
	eval verfs=\$ZFS_VERSION_$version
	typeset current_fs=$rootfs/$verfs
	typeset current_snap=${current_fs}@snap
	typeset current_clone=$rootfs/clone$verfs
	log_must zfs create -o version=${version} ${current_fs}
	log_must zfs snapshot ${current_snap}
	log_must zfs clone ${current_snap} ${current_clone}

	for subversion in $ZFS_ALL_VERSIONS ; do
	typeset subverfs
	eval subverfs=\$ZFS_VERSION_$subversion
	log_must zfs create -o version=${subversion} \
	${current_fs}/$subverfs
	done
	datasets="$datasets ${current_fs}"
	done
	}

	log_assert "Executing 'zfs upgrade [-V version] -a' command succeeds."
	log_onexit cleanup

	rootfs=$TESTPOOL/$TESTFS

	typeset datasets

	typeset newv
	for newv in "" "current" $ZFS_VERSION; do
	setup_datasets
	if [[ -n $newv ]]; then
	opt="-V $newv"
	if [[ $newv == current ]]; then
	newv=$ZFS_VERSION
	fi
	else
	newv=$ZFS_VERSION
	fi

	export __ZFS_POOL_RESTRICT="$TESTPOOL"
	log_must zfs upgrade $opt -a
	unset __ZFS_POOL_RESTRICT

	for fs in $(zfs list -rH -t filesystem -o name $rootfs) ; do
	log_must check_fs_version $fs $newv
	done
	cleanup
	done

	log_pass "Executing 'zfs upgrade [-V version] -a' command succeeds."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zpool_destroy/zpool_destroy_001_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zpool_destroy/zpool_destroy_001_pos.ksh
	index 3323f1db0caf..c25b6c9230a7 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zpool_destroy/zpool_destroy_001_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zpool_destroy/zpool_destroy_001_pos.ksh
	@@ -1,86 +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 2009 Sun Microsystems, Inc. All rights reserved.
	# Use is subject to license terms.
	#

	#
	# Copyright (c) 2012, 2016 by Delphix. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/cli_root/zpool_destroy/zpool_destroy.cfg


	#
	# DESCRIPTION:
	# 'zpool destroy <pool>' can successfully destroy the specified pool.
	#
	# STRATEGY:
	# 1. Create a storage pool
	# 2. Destroy the pool
	# 3. Verify the is destroyed successfully
	#

	verify_runnable "global"

	function cleanup
	{
	poolexists $TESTPOOL2 && destroy_pool $TESTPOOL2
	- datasetexists $TESTPOOL1/$TESTVOL && \
	- log_must zfs destroy -f $TESTPOOL1/$TESTVOL
	+ datasetexists $TESTPOOL1/$TESTVOL && destroy_dataset $TESTPOOL1/$TESTVOL -f

	typeset pool
	for pool in $TESTPOOL1 $TESTPOOL; do
	poolexists $pool && destroy_pool $pool
	done

	[ -n "$recursive" ] && set_tunable64 VOL_RECURSIVE $recursive
	}

	set -A datasets "$TESTPOOL" "$TESTPOOL2"

	log_assert "'zpool destroy <pool>' can destroy a specified pool."

	log_onexit cleanup

	create_pool $TESTPOOL $DISK0
	create_pool $TESTPOOL1 $DISK1
	log_must zfs create -s -V $VOLSIZE $TESTPOOL1/$TESTVOL
	block_device_wait
	if is_freebsd; then
	typeset recursive=$(get_tunable VOL_RECURSIVE)
	log_must set_tunable64 VOL_RECURSIVE 1
	fi
	create_pool $TESTPOOL2 $ZVOL_DEVDIR/$TESTPOOL1/$TESTVOL

	typeset -i i=0
	while (( i < ${#datasets[*]} )); do
	log_must poolexists "${datasets[i]}"
	log_must zpool destroy "${datasets[i]}"
	log_mustnot poolexists "${datasets[i]}"
	((i = i + 1))
	done

	log_pass "'zpool destroy <pool>' executes successfully"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zpool_destroy/zpool_destroy_002_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zpool_destroy/zpool_destroy_002_pos.ksh
	index 794a6c37c37a..a634f10f1114 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zpool_destroy/zpool_destroy_002_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zpool_destroy/zpool_destroy_002_pos.ksh
	@@ -1,117 +1,117 @@
	#!/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) 2012, 2016 by Delphix. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/cli_root/zpool_destroy/zpool_destroy.cfg

	#
	# DESCRIPTION:
	# 'zpool destroy -f <pool>' can forcely destroy the specified pool.
	#
	# STRATEGY:
	# 1. Create a storage pool
	# 2. Create some datasets within the pool
	# 3. Change directory to any mountpoint of these datasets,
	# Verify 'zpool destroy' without '-f' will fail.
	# 4. 'zpool destroy -f' the pool
	# 5. Verify the pool is destroyed successfully
	#

	verify_runnable "global"

	function cleanup
	{
	[[ -n $cwd ]] && log_must cd $cwd

	if [[ -d $TESTDIR ]]; then
	ismounted $TESTDIR && log_must umount $TESTDIR
	log_must rm -rf $TESTDIR
	fi

	typeset -i i=0
	while (( $i < ${#datasets[*]} )); do
	datasetexists ${datasets[i]} && \
	- log_must zfs destroy ${datasets[i]}
	+ destroy_dataset ${datasets[i]}
	(( i = i + 1 ))
	done

	poolexists $TESTPOOL && destroy_pool $TESTPOOL
	}

	set -A datasets "$TESTPOOL/$TESTFS" "$TESTPOOL/$TESTCTR/$TESTFS1" \
	"$TESTPOOL/$TESTCTR" "$TESTPOOL/$TESTVOL" \

	log_assert "'zpool destroy -f <pool>' can forcely destroy the specified pool"

	log_onexit cleanup

	create_pool $TESTPOOL $DISK0
	log_must zfs create $TESTPOOL/$TESTFS
	log_must mkdir -p $TESTDIR
	log_must zfs set mountpoint=$TESTDIR $TESTPOOL/$TESTFS
	log_must zfs create $TESTPOOL/$TESTCTR
	log_must zfs create $TESTPOOL/$TESTCTR/$TESTFS1
	log_must zfs create -V $VOLSIZE $TESTPOOL/$TESTVOL

	typeset -i i=0
	while (( $i < ${#datasets[*]} )); do
	datasetexists "${datasets[i]}" \|\| \
	log_fail "Create datasets fail."
	((i = i + 1))
	done

	log_note "'zpool destroy' without '-f' will fail " \
	"while pool is busy."

	for dir in $TESTDIR /$TESTPOOL/$TESTCTR /$TESTPOOL/$TESTCTR/$TESTFS1 ; do
	log_must cd $dir
	log_mustnot zpool destroy $TESTPOOL

	# Need mount here, otherwise some dataset may be unmounted.
	log_must zfs mount -a

	i=0
	while (( i < ${#datasets[*]} )); do
	datasetexists "${datasets[i]}" \|\| \
	log_fail "Dataset ${datasets[i]} removed unexpected."
	((i = i + 1))
	done
	done

	# 4. 'zpool destroy -f' the pool (unsupported behavior in Linux)
	if is_linux; then
	log_must cd $cwd
	fi

	destroy_pool $TESTPOOL
	log_mustnot poolexists "$TESTPOOL"

	log_pass "'zpool destroy -f <pool>' success."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zpool_history/zpool_history_001_neg.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zpool_history/zpool_history_001_neg.ksh
	index a2b73182bf4c..b5cd8d529ed0 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zpool_history/zpool_history_001_neg.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zpool_history/zpool_history_001_neg.ksh
	@@ -1,69 +1,69 @@
	#!/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.
	#

	. $STF_SUITE/include/libtest.shlib

	#
	# DESCRIPTION:
	# Verify 'zpool history' can deal with non-existent pools and garbage
	# to the command.
	#
	# STRATEGY:
	# 1. Create pool, volume & snap
	# 2. Verify 'zpool history' can cope with incorrect arguments.
	#

	verify_runnable "global"

	snap=$TESTPOOL/$TESTFS@snap
	clone=$TESTPOOL/clone

	set -A neg_opt "$TESTPOOL/$TESTCTR" "$TESTPOOL/$TESTVOL" "-t $TESTPOOL" \
	"-v $TESTPOOL" "$snap" "$clone" "nonexist" "TESTPOOL"

	function cleanup
	{
	- datasetexists $clone && log_must zfs destroy $clone
	- datasetexists $snap && log_must zfs destroy $snap
	+ datasetexists $clone && destroy_dataset $clone
	+ datasetexists $snap && destroy_dataset $snap
	}

	log_assert "Verify 'zpool history' can deal with non-existent pools and " \
	"garbage to the command."
	log_onexit cleanup

	log_must zfs snapshot $snap
	log_must zfs clone $snap $clone

	for opt in "${neg_opt[@]}"; do
	log_mustnot eval "zpool history $opt > /dev/null"
	done

	log_pass "'zpool history' command line negation test passed."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zpool_import/cleanup.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zpool_import/cleanup.ksh
	index d5717ee1561e..bee0e11a4ff4 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zpool_import/cleanup.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zpool_import/cleanup.ksh
	@@ -1,50 +1,49 @@
	#!/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) 2012, 2016 by Delphix. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/cli_root/zpool_import/zpool_import.cfg

	verify_runnable "global"

	log_must set_tunable32 SCAN_SUSPEND_PROGRESS 0

	for pool in "$TESTPOOL" "$TESTPOOL1"; do
	- datasetexists $pool/$TESTFS && \
	- log_must zfs destroy -Rf $pool/$TESTFS
	+ datasetexists $pool/$TESTFS && destroy_dataset $pool/$TESTFS -Rf
	destroy_pool "$pool"
	done

	for dir in "$TESTDIR" "$TESTDIR1" "$DEVICE_DIR" ; do
	[[ -d $dir ]] && \
	log_must rm -rf $dir
	done

	log_pass
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zpool_import/zpool_import_012_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zpool_import/zpool_import_012_pos.ksh
	index a568948e37c4..ec387b225665 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zpool_import/zpool_import_012_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zpool_import/zpool_import_012_pos.ksh
	@@ -1,211 +1,211 @@
	#!/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) 2012, 2016 by Delphix. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/cli_root/zfs_mount/zfs_mount.kshlib
	. $STF_SUITE/tests/functional/cli_root/zpool_import/zpool_import.cfg

	#
	# DESCRIPTION:
	# Once a pool has been exported, it should be recreated after a
	# successful import, all the sub-filesystems within it should all be restored,
	# include mount & share status. Verify that is true.
	#
	# STRATEGY:
	# 1. Create the test pool and hierarchical filesystems.
	# 2. Export the test pool, or destroy the test pool,
	# depend on testing import [-Df].
	# 3. Import it using the various combinations.
	# - Regular import
	# - Alternate Root Specified
	# 4. Verify the mount & share status is restored.
	#

	verify_runnable "global"

	set -A pools "$TESTPOOL" "$TESTPOOL1"
	set -A devs "" "-d $DEVICE_DIR"
	set -A options "" "-R $ALTER_ROOT"
	set -A mtpts "$TESTDIR" "$TESTDIR1"


	function cleanup
	{
	typeset -i i=0

	while ((i < ${#pools[*]})); do
	if poolexists ${pools[i]}; then
	log_must zpool export ${pools[i]}
	log_note "Try to import ${devs[i]} ${pools[i]}"
	zpool import ${devs[i]} ${pools[i]}
	else
	log_note "Try to import $option ${devs[i]} ${pools[i]}"
	zpool import $option ${devs[i]} ${pools[i]}
	fi

	if poolexists ${pools[i]}; then
	is_shared ${pools[i]} && \
	log_must zfs set sharenfs=off ${pools[i]}

	ismounted "${pools[i]}/$TESTFS" \|\| \
	log_must zfs mount ${pools[i]}/$TESTFS
	fi

	((i = i + 1))
	done

	destroy_pool $TESTPOOL1

	- if datasetexists $TESTPOOL/$TESTFS; then
	- log_must zfs destroy -Rf $TESTPOOL/$TESTFS
	- fi
	+ datasetexists $TESTPOOL/$TESTFS && \
	+ destroy_dataset $TESTPOOL/$TESTFS -Rf
	+
	log_must zfs create $TESTPOOL/$TESTFS
	log_must zfs set mountpoint=$TESTDIR $TESTPOOL/$TESTFS

	[[ -d $ALTER_ROOT ]] && \
	log_must rm -rf $ALTER_ROOT
	}

	log_onexit cleanup

	log_assert "Verify all mount & share status of sub-filesystems within a pool \
	can be restored after import [-Df]."

	setup_filesystem "$DEVICE_FILES" $TESTPOOL1 $TESTFS $TESTDIR1
	# create a hierarchy of filesystem
	for pool in ${pools[@]} ; do
	log_must zfs create $pool/$TESTFS/$TESTCTR
	log_must zfs create $pool/$TESTFS/$TESTCTR/$TESTCTR1
	log_must zfs set canmount=off $pool/$TESTFS/$TESTCTR
	log_must zfs set canmount=off $pool/$TESTFS/$TESTCTR/$TESTCTR1
	log_must zfs create $pool/$TESTFS/$TESTCTR/$TESTFS1
	log_must zfs create $pool/$TESTFS/$TESTCTR/$TESTCTR1/$TESTFS1
	log_must zfs create $pool/$TESTFS/$TESTFS1
	log_must zfs snapshot $pool/$TESTFS/$TESTFS1@snap
	log_must zfs clone $pool/$TESTFS/$TESTFS1@snap $pool/$TESTCLONE1
	done

	typeset mount_fs="$TESTFS $TESTFS/$TESTFS1 $TESTCLONE1 \
	$TESTFS/$TESTCTR/$TESTFS1 $TESTFS/$TESTCTR/$TESTCTR1/$TESTFS1"
	typeset nomount_fs="$TESTFS/$TESTCTR $TESTFS/$TESTCTR/$TESTCTR1"

	typeset -i i=0
	typeset -i j=0
	typeset -i nfs_share_bit=0
	typeset -i guid_bit=0
	typeset basedir

	for option in "" "-Df"; do
	i=0
	while ((i < ${#pools[*]})); do
	pool=${pools[i]}
	guid=$(get_pool_prop guid $pool)
	j=0
	while ((j < ${#options[*]})); do
	# set sharenfs property off/on
	nfs_share_bit=0
	while ((nfs_share_bit <= 1)); do
	typeset f_share=""
	typeset nfs_flag="sharenfs=off"
	if ((nfs_share_bit == 1)); then
	log_note "Set sharenfs=on $pool"
	log_must zfs set sharenfs=on $pool
	! is_freebsd && log_must is_shared $pool
	f_share="true"
	nfs_flag="sharenfs=on"
	fi
	# for every off/on nfs bit import guid/pool_name
	guid_bit=0
	while ((guid_bit <= 1)); do
	typeset guid_flag="pool name"
	if [[ -z $option ]]; then
	log_must_busy zpool export $pool
	else
	log_must_busy zpool destroy $pool
	fi

	typeset target=$pool
	if ((guid_bit == 1)); then
	log_note "Import by guid."
	if [[ -z $guid ]]; then
	log_fail "guid should "\
	"not be empty!"
	else
	target=$guid
	guid_flag="$guid"
	fi
	fi
	log_note "Import with $nfs_flag and " \
	"$guid_flag"
	zpool import $option ${devs[i]} \
	${options[j]} $target
	#import by GUID if import by pool name fails
	if [[ $? != 0 ]]; then
	log_note "Possible pool name" \
	"duplicates. Try GUID import"
	target=$guid
	log_must zpool import $option \
	${devs[i]} ${options[j]} \
	$target
	fi
	log_must poolexists $pool

	for fs in $mount_fs; do
	log_must ismounted $pool/$fs
	[[ -n $f_share ]] && \
	! is_freebsd && \
	log_must is_shared $pool/$fs
	done

	for fs in $nomount_fs; do
	log_mustnot ismounted $pool/$fs
	! is_freebsd && \
	log_mustnot is_shared $pool/$fs
	done
	((guid_bit = guid_bit + 1))
	done
	# reset nfsshare=off
	if [[ -n $f_share ]]; then
	log_must zfs set sharenfs=off $pool
	! is_freebsd && log_mustnot is_shared $pool
	fi
	((nfs_share_bit = nfs_share_bit + 1))
	done

	((j = j + 1))
	done

	((i = i + 1))
	done
	done

	log_pass "All mount & share status of sub-filesystems within a pool \
	can be restored after import [-Df]."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zpool_scrub/zpool_scrub_encrypted_unloaded.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zpool_scrub/zpool_scrub_encrypted_unloaded.ksh
	index a8c15424db27..b1f7c6264b01 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zpool_scrub/zpool_scrub_encrypted_unloaded.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zpool_scrub/zpool_scrub_encrypted_unloaded.ksh
	@@ -1,67 +1,67 @@
	#!/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) 2017 Datto, Inc. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib

	#
	# DESCRIPTION:
	# Scrubs must work on an encrypted dataset with an unloaded key.
	#
	# STRATEGY:
	# 1. Create an encrypted dataset
	# 2. Generate data on the dataset
	# 3. Unmount the encrypted dataset and unload its key
	# 4. Start a scrub
	# 5. Wait for the scrub to complete
	# 6. Verify the scrub had no errors
	# 7. Load the dataset key and mount it
	#

	verify_runnable "global"

	function cleanup
	{
	datasetexists $TESTPOOL/$TESTFS2 && \
	- log_must zfs destroy $TESTPOOL/$TESTFS2
	+ destroy_dataset $TESTPOOL/$TESTFS2
	}
	log_onexit cleanup

	log_assert "Scrubs must work on an encrypted dataset with an unloaded key"

	log_must eval "echo 'password' \| zfs create -o encryption=on" \
	"-o keyformat=passphrase $TESTPOOL/$TESTFS2"

	typeset mntpnt=$(get_prop mountpoint $TESTPOOL/$TESTFS2)
	log_must mkfile 10m $mntpnt/file1

	for i in 2..10; do
	log_must mkfile 512b $mntpnt/file$i
	done

	log_must zfs unmount $TESTPOOL/$TESTFS2
	log_must zfs unload-key $TESTPOOL/$TESTFS2

	log_must zpool scrub -w $TESTPOOL

	log_must check_pool_status $TESTPOOL "scan" "with 0 errors"

	log_must eval "echo 'password' \| zfs mount -l $TESTPOOL/$TESTFS2"

	log_pass "Scrubs work on an encrypted dataset with an unloaded key"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/features/async_destroy/async_destroy_001_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/features/async_destroy/async_destroy_001_pos.ksh
	index 23fb16d6ed5a..ad0e49f8fb40 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/features/async_destroy/async_destroy_001_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/features/async_destroy/async_destroy_001_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) 2013, 2016 by Delphix. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib

	#
	# DESCRIPTION:
	# Exercise the traversal suspend/resume code in async_destroy by
	# destroying a file system that has more blocks than we can free
	# in a single txg.
	#
	# STRATEGY:
	# 1. Create a file system
	# 2. Set recordsize to 512 to create the maximum number of blocks
	# 3. Set compression to off to force zero-ed blocks to be written
	# 4. dd a lot of data from /dev/zero to the file system
	# 5. Destroy the file system
	# 6. Wait for the freeing property to go to 0
	# 7. Use zdb to check for leaked blocks
	#

	TEST_FS=$TESTPOOL/async_destroy

	verify_runnable "both"

	function cleanup
	{
	- datasetexists $TEST_FS && log_must zfs destroy $TEST_FS
	+ datasetexists $TEST_FS && destroy_dataset $TEST_FS
	log_must set_tunable64 ASYNC_BLOCK_MAX_BLOCKS 100000
	}

	log_onexit cleanup
	log_assert "async_destroy can suspend and resume traversal"

	log_must zfs create -o recordsize=1k -o compression=off $TEST_FS

	# Fill with 128,000 blocks.
	log_must dd bs=1024k count=128 if=/dev/zero of=/$TEST_FS/file

	#
	# Decrease the max blocks to free each txg, so that freeing takes
	# long enough that we can observe it.
	#
	log_must set_tunable64 ASYNC_BLOCK_MAX_BLOCKS 100

	log_must sync
	log_must zfs destroy $TEST_FS

	#
	# We monitor the freeing property, to verify we can see blocks being
	# freed while the suspend/resume code is exercised.
	#
	t0=$SECONDS
	count=0
	while [[ $((SECONDS - t0)) -lt 10 ]]; do
	[[ "0" != "$(zpool list -Ho freeing $TESTPOOL)" ]] && ((count++))
	[[ $count -gt 1 ]] && break
	sleep 1
	done

	[[ $count -eq 0 ]] && log_fail "Freeing property remained empty"

	#
	# After a bit, go back to allowing an unlimited amount of freeing
	# per txg.
	#
	sleep 10
	log_must set_tunable64 ASYNC_BLOCK_MAX_BLOCKS 100000

	# Wait for everything to be freed.
	while [[ "0" != "$(zpool list -Ho freeing $TESTPOOL)" ]]; do
	[[ $((SECONDS - t0)) -gt 180 ]] && \
	log_fail "Timed out waiting for freeing to drop to zero"
	done

	# Check for leaked blocks.
	log_must zdb -b $TESTPOOL

	log_pass "async_destroy can suspend and resume traversal"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/features/large_dnode/large_dnode_001_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/features/large_dnode/large_dnode_001_pos.ksh
	index d3530292e81a..cb1e940a7d73 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/features/large_dnode/large_dnode_001_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/features/large_dnode/large_dnode_001_pos.ksh
	@@ -1,82 +1,82 @@
	#!/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 by Lawrence Livermore National Security, LLC.
	# Use is subject to license terms.
	#

	. $STF_SUITE/include/libtest.shlib

	#
	# DESCRIPTION:
	# Verify that the dnode sizes of newly created files are consistent
	# with the dnodesize dataset property.
	#
	# STRATEGY:
	# 1. Create a file system
	# 2. Set dnodesize to a legal literal value
	# 3. Create a file
	# 4. Repeat 2-3 for all legal literal values of dnodesize values
	# 5. Unmount the file system
	# 6. Use zdb to check expected dnode sizes
	#

	TEST_FS=$TESTPOOL/large_dnode

	verify_runnable "both"

	function cleanup
	{
	- datasetexists $TEST_FS && log_must zfs destroy $TEST_FS
	+ datasetexists $TEST_FS && destroy_dataset $TEST_FS
	}

	log_onexit cleanup
	log_assert "dnode sizes are consistent with dnodesize dataset property"

	log_must zfs create $TEST_FS

	set -A dnsizes "512" "1k" "2k" "4k" "8k" "16k"
	set -A inodes

	for ((i=0; i < ${#dnsizes[*]}; i++)) ; do
	size=${dnsizes[$i]}
	if [[ $size == "512" ]] ; then
	size="legacy"
	fi
	file=/$TEST_FS/file.$size
	log_must zfs set dnsize=$size $TEST_FS
	touch $file
	inodes[$i]=$(ls -li $file \| awk '{print $1}')
	done

	log_must zfs umount $TEST_FS

	for ((i=0; i < ${#dnsizes[*]}; i++)) ; do
	dnsize=$(zdb -dddd $TEST_FS ${inodes[$i]} \|
	awk '/ZFS plain file/ {print $6}' \| tr K k)
	if [[ "$dnsize" != "${dnsizes[$i]}" ]]; then
	log_fail "dnode size is $dnsize (expected ${dnsizes[$i]})"
	fi
	done

	log_pass "dnode sizes are consistent with dnodesize dataset property"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/features/large_dnode/large_dnode_002_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/features/large_dnode/large_dnode_002_pos.ksh
	index c2b32ad66217..9a00ceeb3cef 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/features/large_dnode/large_dnode_002_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/features/large_dnode/large_dnode_002_pos.ksh
	@@ -1,83 +1,83 @@
	#!/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 by Lawrence Livermore National Security, LLC.
	# Use is subject to license terms.
	#

	. $STF_SUITE/include/libtest.shlib

	#
	# DESCRIPTION:
	# Verify that extended attributes can use extra bonus space of a large
	# dnode without kicking in a spill block.
	#
	# STRATEGY:
	# 1. Create a file system with xattr=sa
	# 2. Set dnodesize to a legal literal value
	# 3. Create a file
	# 4 Store an xattr that fits within the dnode size
	# 4. Repeat 2-3 for all legal literal values of dnodesize values
	# 5. Unmount the file system
	# 6. Use zdb to check for missing SPILL_BLKPTR flag
	#

	TEST_FS=$TESTPOOL/large_dnode

	verify_runnable "both"

	function cleanup
	{
	- datasetexists $TEST_FS && log_must zfs destroy $TEST_FS
	+ datasetexists $TEST_FS && destroy_dataset $TEST_FS
	}

	log_onexit cleanup
	log_assert "extended attributes use extra bonus space of a large dnode"

	log_must zfs create -o xattr=sa $TEST_FS

	# Store dnode size minus 512 in an xattr
	set -A xattr_sizes "512" "1536" "3584" "7680" "15872"
	set -A prop_values "1k" "2k" "4k" "8k" "16k"
	set -A inodes

	for ((i=0; i < ${#prop_values[*]}; i++)) ; do
	prop_val=${prop_values[$i]}
	file=/$TEST_FS/file.$prop_val
	log_must zfs set dnsize=$prop_val $TEST_FS
	touch $file
	xattr_size=${xattr_sizes[$i]}
	xattr_name=user.foo
	xattr_val=$(dd if=/dev/urandom bs=1 count=$xattr_size \|
	openssl enc -a -A)
	log_must setfattr -n $xattr_name -v 0s$xattr_val $file
	inodes[$i]=$(ls -li $file \| awk '{print $1}')
	done

	log_must zfs umount $TEST_FS

	for ((i=0; i < ${#inodes[*]}; i++)) ; do
	log_mustnot eval "zdb -dddd $TEST_FS ${inodes[$i]} \| grep SPILL_BLKPTR"
	done

	log_pass "extended attributes use extra bonus space of a large dnode"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/features/large_dnode/large_dnode_004_neg.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/features/large_dnode/large_dnode_004_neg.ksh
	index 3fa1cabe063a..2cc587b47879 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/features/large_dnode/large_dnode_004_neg.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/features/large_dnode/large_dnode_004_neg.ksh
	@@ -1,73 +1,71 @@
	#!/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 by Lawrence Livermore National Security, LLC.
	# Use is subject to license terms.
	#

	#
	# 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

	verify_runnable "both"

	TEST_FS=$TESTPOOL/large_dnode
	TEST_SNAP=$TESTPOOL/large_dnode@ldnsnap
	TEST_STREAM=$TESTDIR/ldnsnap

	function cleanup
	{
	- if datasetexists $TEST_FS ; then
	- log_must zfs destroy -r $TEST_FS
	- fi
	+ datasetexists $TEST_FS && destroy_dataset $TEST_FS -r

	if datasetexists $LGCYPOOL ; then
	log_must zpool destroy -f $LGCYPOOL
	fi

	rm -f $TEST_STREAM
	}

	log_onexit cleanup
	log_assert "zfs send stream with large dnodes not accepted by legacy pool"

	log_must zfs create -o dnodesize=1k $TEST_FS
	log_must touch /$TEST_FS/foo
	log_must zfs umount $TEST_FS
	log_must zfs snap $TEST_SNAP
	log_must eval "zfs send $TEST_SNAP > $TEST_STREAM"

	LGCYPOOL=ldnpool
	LGCYFS=$LGCYPOOL/legacy
	log_must mkfile 64M $TESTDIR/$LGCYPOOL
	log_must zpool create -d $LGCYPOOL $TESTDIR/$LGCYPOOL
	log_mustnot eval "zfs recv $LGCYFS < $TEST_STREAM"

	log_pass
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/features/large_dnode/large_dnode_005_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/features/large_dnode/large_dnode_005_pos.ksh
	index a2d92673b180..2be98942634f 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/features/large_dnode/large_dnode_005_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/features/large_dnode/large_dnode_005_pos.ksh
	@@ -1,80 +1,75 @@
	#!/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 by Lawrence Livermore National Security, LLC.
	# Use is subject to license terms.
	#

	. $STF_SUITE/include/libtest.shlib

	verify_runnable "both"

	TEST_SEND_FS=$TESTPOOL/send_large_dnode
	TEST_RECV_FS=$TESTPOOL/recv_large_dnode
	TEST_SNAP=$TEST_SEND_FS@ldnsnap
	TEST_SNAPINCR=$TEST_SEND_FS@ldnsnap_incr
	TEST_STREAM=$TESTDIR/ldnsnap
	TEST_STREAMINCR=$TESTDIR/ldnsnap_incr
	TEST_FILE=foo
	TEST_FILEINCR=bar

	function cleanup
	{
	- if datasetexists $TEST_SEND_FS ; then
	- log_must zfs destroy -r $TEST_SEND_FS
	- fi
	-
	- if datasetexists $TEST_RECV_FS ; then
	- log_must zfs destroy -r $TEST_RECV_FS
	- fi
	+ datasetexists $TEST_SEND_FS && destroy_dataset $TEST_SEND_FS -r
	+ datasetexists $TEST_RECV_FS && destroy_dataset $TEST_RECV_FS -r

	rm -f $TEST_STREAM
	rm -f $TEST_STREAMINCR
	}

	log_onexit cleanup

	log_assert "zfs send stream with large dnodes accepted by new pool"

	log_must zfs create -o dnodesize=1k $TEST_SEND_FS
	log_must touch /$TEST_SEND_FS/$TEST_FILE
	log_must zfs snap $TEST_SNAP
	log_must zfs send $TEST_SNAP > $TEST_STREAM
	log_must rm -f /$TEST_SEND_FS/$TEST_FILE
	log_must touch /$TEST_SEND_FS/$TEST_FILEINCR
	log_must zfs snap $TEST_SNAPINCR
	log_must zfs send -i $TEST_SNAP $TEST_SNAPINCR > $TEST_STREAMINCR

	log_must eval "zfs recv $TEST_RECV_FS < $TEST_STREAM"
	inode=$(ls -li /$TEST_RECV_FS/$TEST_FILE \| awk '{print $1}')
	dnsize=$(zdb -dddd $TEST_RECV_FS $inode \| awk '/ZFS plain file/ {print $6}')
	if [[ "$dnsize" != "1K" ]]; then
	log_fail "dnode size is $dnsize (expected 1K)"
	fi

	log_must eval "zfs recv -F $TEST_RECV_FS < $TEST_STREAMINCR"
	log_must diff -r /$TEST_SEND_FS /$TEST_RECV_FS
	log_must zfs umount $TEST_SEND_FS
	log_must zfs umount $TEST_RECV_FS

	log_pass
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/features/large_dnode/large_dnode_006_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/features/large_dnode/large_dnode_006_pos.ksh
	index 38b4ac52e5d6..3727bd5c11d2 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/features/large_dnode/large_dnode_006_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/features/large_dnode/large_dnode_006_pos.ksh
	@@ -1,72 +1,72 @@
	#!/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 by Lawrence Livermore National Security, LLC.
	# Use is subject to license terms.
	#

	#
	# 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

	#
	# DESCRIPTION:
	# Run xattrtest on a dataset with large dnodes and xattr=sa
	# to stress xattr usage of the extra bonus space and verify
	# contents
	#

	TEST_FS=$TESTPOOL/large_dnode

	verify_runnable "both"

	function cleanup
	{
	- datasetexists $TEST_FS && log_must zfs destroy $TEST_FS
	+ datasetexists $TEST_FS && destroy_dataset $TEST_FS
	}

	log_onexit cleanup
	log_assert "xattrtest runs cleanly on dataset with large dnodes"

	log_must zfs create $TEST_FS

	set -A xattr_sizes "512" "1536" "3584" "7680" "15872"
	set -A prop_values "1k" "2k" "4k" "8k" "16k"

	for ((i=0; i < ${#prop_values[*]}; i++)) ; do
	prop_val=${prop_values[$i]}
	dir=/$TEST_FS/$prop_val
	xattr_size=${xattr_sizes[$i]}
	log_must zfs set dnsize=$prop_val $TEST_FS
	log_must mkdir $dir
	log_must xattrtest -R -y -s $xattr_size -f 1024 -p $dir
	done

	log_pass
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/features/large_dnode/large_dnode_009_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/features/large_dnode/large_dnode_009_pos.ksh
	index fa746c52e5c5..1e42202069eb 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/features/large_dnode/large_dnode_009_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/features/large_dnode/large_dnode_009_pos.ksh
	@@ -1,71 +1,71 @@
	#!/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.
	#

	. $STF_SUITE/include/libtest.shlib

	#
	# DESCRIPTION:
	# Run many xattrtests on a dataset with large dnodes and xattr=sa to
	# stress concurrent allocation of large dnodes.
	#

	TEST_FS=$TESTPOOL/large_dnode

	verify_runnable "both"

	function cleanup
	{
	- datasetexists $TEST_FS && log_must zfs destroy $TEST_FS
	+ datasetexists $TEST_FS && destroy_dataset $TEST_FS
	}

	log_onexit cleanup
	log_assert "xattrtest runs concurrently on dataset with large dnodes"

	log_must zfs create $TEST_FS
	log_must zfs set dnsize=auto $TEST_FS
	log_must zfs set xattr=sa $TEST_FS

	for ((i=0; i < 100; i++)); do
	dir="/$TEST_FS/dir.$i"
	log_must mkdir "$dir"

	do_unlink=""
	if [ $((RANDOM % 2)) -eq 0 ]; then
	do_unlink="-k -f 1024"
	else
	do_unlink="-f $((RANDOM % 1024))"
	fi
	log_must eval "xattrtest -R -r -y -x 1 $do_unlink -p $dir >/dev/null 2>&1 &"
	done

	log_must wait

	-log_must zpool export $TESTPOOL
	+log_must_busy zpool export $TESTPOOL
	log_must zpool import $TESTPOOL
	log_must ls -lR "/$TEST_FS/" >/dev/null 2>&1
	log_must zdb -d $TESTPOOL
	log_pass
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/history/history_002_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/history/history_002_pos.ksh
	index a53bcaf4ec64..b431cdc5f144 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/history/history_002_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/history/history_002_pos.ksh
	@@ -1,199 +1,199 @@
	#!/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/tests/functional/history/history_common.kshlib

	#
	# DESCRIPTION:
	# Create a scenario to verify the following zfs subcommands are logged.
	# create, destroy, clone, rename, snapshot, rollback, set, inherit,
	# receive, promote, hold and release.
	#
	# STRATEGY:
	# 1. Verify that all the zfs commands listed (barring send) produce an
	# entry in the pool history.
	#

	verify_runnable "global"

	function cleanup
	{

	[[ -f $tmpfile ]] && rm -f $tmpfile
	[[ -f $tmpfile2 ]] && rm -f $tmpfile2
	for dataset in $fs $newfs $fsclone $vol $newvol $volclone; do
	- datasetexists $dataset && zfs destroy -Rf $dataset
	+ datasetexists $dataset && destroy_dataset $dataset -Rf
	done
	rm -rf /history.$$
	}

	log_assert "Verify zfs sub-commands which modify state are logged."
	log_onexit cleanup

	fs=$TESTPOOL/$TESTFS1; newfs=$TESTPOOL/newfs; fsclone=$TESTPOOL/clone
	vol=$TESTPOOL/$TESTVOL ; newvol=$TESTPOOL/newvol; volclone=$TESTPOOL/volclone
	fssnap=$fs@fssnap; fssnap2=$fs@fssnap2
	volsnap=$vol@volsnap; volsnap2=$vol@volsnap2
	tmpfile=$TEST_BASE_DIR/tmpfile.$$ ; tmpfile2=$TEST_BASE_DIR/tmpfile2.$$

	if is_linux; then
	# property value property value
	#
	props=(
	quota 64M recordsize 512
	reservation 32M reservation none
	mountpoint /history.$$ mountpoint legacy
	mountpoint none compression lz4
	compression on compression off
	compression lzjb acltype off
	acltype posix acltype nfsv4
	atime on atime off
	devices on devices off
	exec on exec off
	setuid on setuid off
	readonly on readonly off
	zoned on zoned off
	snapdir hidden snapdir visible
	aclinherit discard aclinherit noallow
	aclinherit secure aclinherit passthrough
	canmount off canmount on
	compression gzip compression gzip-$((RANDOM%9 + 1))
	compression zstd compression zstd-$((RANDOM%9 + 1))
	compression zstd-fast copies $((RANDOM%3 + 1))
	compression zstd-fast-$((RANDOM%9 + 1)) xattr sa
	xattr on xattr off
	)
	elif is_freebsd; then
	# property value property value
	#
	props=(
	quota 64M recordsize 512
	reservation 32M reservation none
	mountpoint /history.$$ mountpoint legacy
	mountpoint none sharenfs on
	sharenfs off
	compression on compression off
	compression lzjb aclmode discard
	aclmode groupmask aclmode passthrough
	atime on atime off
	devices on devices off
	exec on exec off
	setuid on setuid off
	readonly on readonly off
	jailed on jailed off
	snapdir hidden snapdir visible
	aclinherit discard aclinherit noallow
	aclinherit secure aclinherit passthrough
	canmount off canmount on
	compression gzip compression gzip-$((RANDOM%9 + 1))
	compression zstd compression zstd-$((RANDOM%9 + 1))
	compression zstd-fast copies $((RANDOM%3 + 1))
	compression zstd-fast-$((RANDOM%9 + 1)) acltype off
	acltype posix acltype nfsv4
	)
	else
	# property value property value
	#
	props=(
	quota 64M recordsize 512
	reservation 32M reservation none
	mountpoint /history.$$ mountpoint legacy
	mountpoint none sharenfs on
	sharenfs off
	compression on compression off
	compression lzjb aclmode discard
	aclmode groupmask aclmode passthrough
	atime on atime off
	devices on devices off
	exec on exec off
	setuid on setuid off
	readonly on readonly off
	zoned on zoned off
	snapdir hidden snapdir visible
	aclinherit discard aclinherit noallow
	aclinherit secure aclinherit passthrough
	canmount off canmount on
	xattr on xattr off
	compression gzip compression gzip-$((RANDOM%9 + 1))
	copies $((RANDOM%3 + 1))
	)
	fi

	run_and_verify "zfs create $fs"
	# Set all the property for filesystem
	typeset -i i=0
	while ((i < ${#props[@]})) ; do
	run_and_verify "zfs set ${props[$i]}=${props[((i+1))]} $fs"

	# quota, reservation, canmount can not be inherited.
	#
	if [[ ${props[$i]} != "quota" && ${props[$i]} != "reservation" && \
	${props[$i]} != "canmount" ]];
	then
	run_and_verify "zfs inherit ${props[$i]} $fs"
	fi

	((i += 2))
	done

	run_and_verify "zfs create -V 64M $vol"
	run_and_verify "zfs set volsize=32M $vol"
	run_and_verify "zfs snapshot $fssnap"
	run_and_verify "zfs hold tag $fssnap"
	run_and_verify "zfs release tag $fssnap"
	run_and_verify "zfs snapshot $volsnap"
	run_and_verify "zfs snapshot $fssnap2"
	run_and_verify "zfs snapshot $volsnap2"

	# Send isn't logged...
	log_must eval "zfs send -i $fssnap $fssnap2 > $tmpfile"
	log_must eval "zfs send -i $volsnap $volsnap2 > $tmpfile2"
	# Verify that's true
	zpool history $TESTPOOL \| grep 'zfs send' >/dev/null 2>&1 && \
	log_fail "'zfs send' found in history of \"$TESTPOOL\""

	run_and_verify "zfs destroy $fssnap2"
	run_and_verify "zfs destroy $volsnap2"
	run_and_verify "zfs receive $fs < $tmpfile"
	run_and_verify "zfs receive $vol < $tmpfile2"
	run_and_verify "zfs rollback -r $fssnap"
	run_and_verify "zfs rollback -r $volsnap"
	run_and_verify "zfs clone $fssnap $fsclone"
	run_and_verify "zfs clone $volsnap $volclone"
	run_and_verify "zfs rename $fs $newfs"
	run_and_verify "zfs rename $vol $newvol"
	run_and_verify "zfs promote $fsclone"
	run_and_verify "zfs promote $volclone"
	run_and_verify "zfs destroy $newfs"
	run_and_verify "zfs destroy $newvol"
	run_and_verify "zfs destroy -rf $fsclone"
	run_and_verify "zfs destroy -rf $volclone"

	log_pass "zfs sub-commands which modify state are logged passed."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/history/history_006_neg.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/history/history_006_neg.ksh
	index e97adc4e3ce0..19b7114faf5b 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/history/history_006_neg.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/history/history_006_neg.ksh
	@@ -1,88 +1,86 @@
	#!/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/tests/functional/history/history_common.kshlib
	. $STF_SUITE/include/libtest.shlib

	#
	# DESCRIPTION:
	# Verify the following zfs subcommands are not logged.
	# list, get, holds, mount, unmount, share, unshare, send
	#
	# STRATEGY:
	# 1. Create a test pool.
	# 2. Separately invoke zfs list\|get\|holds\|mount\|unmount\|share\|unshare\|send
	# 3. Verify they were not recorded in pool history.
	#

	verify_runnable "global"

	function cleanup
	{
	- if datasetexists $fs ; then
	- log_must zfs destroy -rf $fs
	- fi
	+ datasetexists $fs && destroy_dataset $fs -rf
	log_must zfs create $fs
	}

	log_assert "Verify 'zfs list\|get\|holds\|mount\|unmount\|share\|unshare\|send' " \
	"will not be logged."
	log_onexit cleanup

	# Create initial test environment
	fs=$TESTPOOL/$TESTFS; snap1=$fs@snap1; snap2=$fs@snap2
	if ! is_linux; then
	log_must zfs set sharenfs=on $fs
	fi
	log_must zfs snapshot $snap1
	log_must zfs hold tag $snap1
	log_must zfs snapshot $snap2

	# Save initial TESTPOOL history
	log_must eval "zpool history $TESTPOOL > $OLD_HISTORY"

	log_must zfs list $fs > /dev/null
	log_must zfs get mountpoint $fs > /dev/null
	log_must zfs unmount $fs
	log_must zfs mount $fs
	if ! is_linux; then
	log_must zfs share $fs
	log_must zfs unshare $fs
	fi
	log_must zfs send -i $snap1 $snap2 > /dev/null
	log_must zfs holds $snap1

	log_must eval "zpool history $TESTPOOL > $NEW_HISTORY"
	log_must diff $OLD_HISTORY $NEW_HISTORY

	log_must zfs release tag $snap1

	log_pass "Verify 'zfs list\|get\|mount\|unmount\|share\|unshare\|send' passed."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/history/history_007_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/history/history_007_pos.ksh
	index 0504e1765c63..591d5b85e885 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/history/history_007_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/history/history_007_pos.ksh
	@@ -1,112 +1,112 @@
	#!/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/history/history_common.kshlib

	#
	# DESCRIPTION:
	# Verify command history moves with pool while pool being migrated
	#
	# STRATEGY:
	# 1. Import uniform platform and cross platform pools
	# 2. Contract the command history of the imported pool
	# 3. Compare imported history log with the previous log.
	#

	verify_runnable "global"

	function cleanup
	{
	poolexists $migratedpoolname && \
	log_must zpool destroy -f $migratedpoolname

	[[ -d $import_dir ]] && rm -rf $import_dir
	}

	log_assert "Verify command history moves with migrated pool."
	log_onexit cleanup

	tst_dir=$STF_SUITE/tests/functional/history
	import_dir=$TESTDIR/importdir.$$
	migrated_cmds_f=$import_dir/migrated_history.$$
	migratedpoolname=$MIGRATEDPOOLNAME
	typeset -i RET=1
	typeset -i linenum=0

	-[[ ! -d $import_dir ]] && log_must mkdir $import_dir
	+[[ ! -d $import_dir ]] && log_must mkdir -p $import_dir

	# We test the migrations on both uniform platform and cross platform
	for arch in "i386" "sparc"; do
	log_must cp $tst_dir/${arch}.orig_history.txt $import_dir
	orig_cmds_f=$import_dir/${arch}.orig_history.txt
	# remove blank line
	orig_cmds_f1=$import_dir/${arch}.orig_history_1.txt
	cat $orig_cmds_f \| grep -v "^$" > $orig_cmds_f1

	log_must cp $tst_dir/${arch}.migratedpool.DAT.Z $import_dir
	log_must uncompress -f $import_dir/${arch}.migratedpool.DAT.Z

	# destroy the pool with same name, so that import operation succeeds.
	poolexists $migratedpoolname && \
	log_must zpool destroy -f $migratedpoolname

	log_must zpool import -d $import_dir $migratedpoolname
	TZ=$TIMEZONE zpool history $migratedpoolname \| grep -v "^$" \
	>$migrated_cmds_f
	RET=$?
	(( $RET != 0 )) && log_fail "zpool history $migratedpoolname fails."

	# The migrated history file should differ with original history file on
	# two commands -- 'export' and 'import', which are included in migrated
	# history file but not in original history file. so, check the two
	# commands firstly in migrated history file and then delete them, and
	# then compare this filtered file with the original history file. They
	# should be identical at this time.
	for subcmd in "export" "import"; do
	grep "$subcmd" $migrated_cmds_f >/dev/null 2>&1
	RET=$?
	(( $RET != 0 )) && log_fail "zpool $subcmd is not logged for" \
	"the imported pool $migratedpoolname."
	done

	tmpfile=$import_dir/cmds_tmp.$$
	linenum=`cat $migrated_cmds_f \| wc -l`
	(( linenum = linenum - 2 ))
	head -n $linenum $migrated_cmds_f > $tmpfile
	log_must diff $tmpfile $orig_cmds_f1

	# cleanup for next loop testing
	log_must zpool destroy -f $migratedpoolname
	log_must rm -f `ls $import_dir`
	done

	log_pass "Verify command history moves with migrated pool."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/history/history_008_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/history/history_008_pos.ksh
	index 996c7658c32c..8e174dcb7ebf 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/history/history_008_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/history/history_008_pos.ksh
	@@ -1,74 +1,72 @@
	#!/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/tests/functional/history/history_common.kshlib

	#
	# DESCRIPTION:
	# Pool history records all recursive operations.
	#
	# STRATEGY:
	# 1. Create a filesystem and several sub-filesystems in it.
	# 2. Make a recursive snapshot.
	# 3. Verify pool history records all the recursive operations.
	# 4. Do the same verification for hold, release, inherit, rollback and
	# destroy.
	#

	verify_runnable "global"

	function cleanup
	{
	- if datasetexists $root_testfs; then
	- log_must zfs destroy -rf $root_testfs
	- fi
	+ datasetexists $root_testfs && destroy_dataset $root_testfs -rf
	log_must zfs create $root_testfs
	}

	log_assert "Pool history records all recursive operations."
	log_onexit cleanup

	root_testfs=$TESTPOOL/$TESTFS
	fs1=$root_testfs/fs1; fs2=$root_testfs/fs2; fs3=$root_testfs/fs3
	for fs in $fs1 $fs2 $fs3; do
	log_must zfs create $fs
	done

	run_and_verify "zfs snapshot -r $root_testfs@snap" "-i"
	run_and_verify "zfs hold -r tag $root_testfs@snap" "-i"
	run_and_verify "zfs release -r tag $root_testfs@snap" "-i"
	log_must zfs snapshot $root_testfs@snap2
	log_must zfs snapshot $root_testfs@snap3
	run_and_verify "zfs rollback -r $root_testfs@snap" "-i"
	run_and_verify "zfs inherit -r mountpoint $root_testfs" "-i"
	run_and_verify "zfs destroy -r $root_testfs" "-i"

	log_pass "Pool history records all recursive operations."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/history/history_010_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/history/history_010_pos.ksh
	index 31fe8ec54d0e..2c32b1b6cefa 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/history/history_010_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/history/history_010_pos.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 2009 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/history/history_common.kshlib

	#
	# DESCRIPTION:
	# Verify internal long history information are correct.
	#
	# STRATEGY:
	# 1. Create non-root test user and group.
	# 2. Do some zfs operations as a root and non-root user.
	# 3. Verify the long history information is correct.
	#

	verify_runnable "global"

	function cleanup
	{
	del_user $HIST_USER
	del_group $HIST_GROUP
	- datasetexists $root_testfs && log_must zfs destroy -rf $root_testfs
	+ datasetexists $root_testfs && destroy_dataset $root_testfs -rf
	}

	log_assert "Verify internal long history information are correct."
	log_onexit cleanup

	root_testfs=$TESTPOOL/$TESTFS1

	# Create history test group and user and get user id and group id
	add_group $HIST_GROUP
	add_user $HIST_GROUP $HIST_USER

	#
	# Verify the test user can execute the zfs utilities. This may not
	# be possible due to default permissions on the user home directory.
	# This can be resolved granting group read access.
	#
	# chmod 0750 $HOME
	#
	user_run $HIST_USER zfs list
	if [ $? -ne 0 ]; then
	log_unsupported "Test user $HIST_USER cannot execute zfs utilities"
	fi

	run_and_verify "zfs create $root_testfs" "-l"
	run_and_verify "zfs allow $HIST_GROUP snapshot,mount $root_testfs" "-l"
	run_and_verify "zfs allow $HIST_USER destroy,mount $root_testfs" "-l"
	run_and_verify "zfs allow $HIST_USER reservation $root_testfs" "-l"
	run_and_verify "zfs allow $HIST_USER allow $root_testfs" "-l"
	run_and_verify -u "$HIST_USER" "zfs snapshot $root_testfs@snap" "-l"
	run_and_verify -u "$HIST_USER" "zfs destroy $root_testfs@snap" "-l"
	run_and_verify -u "$HIST_USER" "zfs set reservation=64M $root_testfs" "-l"
	run_and_verify -u "$HIST_USER" \
	"zfs allow $HIST_USER reservation $root_testfs" "-l"
	run_and_verify "zfs unallow $HIST_USER create $root_testfs" "-l"
	run_and_verify "zfs unallow $HIST_GROUP snapshot $root_testfs" "-l"
	run_and_verify "zfs destroy -r $root_testfs" "-l"

	log_pass "Verify internal long history information pass."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/history/history_common.kshlib b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/history/history_common.kshlib
	index 8ac34b2de909..ff3260f3c0f2 100644
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/history/history_common.kshlib
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/history/history_common.kshlib
	@@ -1,422 +1,422 @@
	#
	# 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/history/history.cfg

	function run_and_verify
	{
	typeset user pool
	while getopts "p:u:" opt; do
	case $opt in
	p)
	pool=$OPTARG
	;;
	u)
	user=$OPTARG
	;;
	esac
	done
	shift $(($OPTIND - 1))

	pool=${pool:-$TESTPOOL}
	user=${user:-"root"}
	fullcmd="$1"
	flags="$2"

	if is_illumos; then
	histcmd=$(echo $fullcmd \| sed 's/\/usr\/sbin\///g')
	else
	histcmd=$(echo $fullcmd \| sed 's/^.\/$zpool .$.*$/\1/')
	histcmd=$(echo $histcmd \| sed 's/^.\/$zfs .$.*$/\1/')
	fi

	cmd=$(echo $histcmd \| awk '{print $1}')
	subcmd=$(echo $histcmd \| awk '{print $2}')

	# If we aren't running zpool or zfs, something is wrong
	[[ $cmd == "zpool" \|\| $cmd == "zfs" ]] \|\| \
	log_fail "run_and_verify called with \"$cmd ($fullcmd)\""

	# If this is a 'zfs receive' truncate the stdin redirect
	[[ $subcmd == "receive" \|\| $subcmd == "recv" ]] && \
	histcmd=${histcmd%% <*}

	# Run the command as the specified user, and find the new history.
	zpool history $flags $pool > $OLD_HISTORY 2>/dev/null
	if [[ $user == "root" ]]; then
	- log_must eval "$fullcmd"
	+ log_must_busy eval "$fullcmd"
	else
	- log_must user_run $user "$fullcmd"
	+ log_must_busy user_run $user "$fullcmd"
	fi
	zpool history $flags $pool > $TMP_HISTORY 2>/dev/null
	diff $OLD_HISTORY $TMP_HISTORY \| grep "^> " \| sed 's/^> //g' \
	> $NEW_HISTORY

	# Verify what's common to every case, regardless of zpool history flags.
	grep "$histcmd" $NEW_HISTORY >/dev/null 2>&1 \|\| \
	log_fail "Didn't find \"$histcmd\" in pool history"

	# If 'zpool history' was called without any flags, then we're done.
	[[ -z $flags ]] && return

	# Verify the new history in cases that are more interesting because
	# additional information is logged with -i or -l.

	[[ $flags =~ "i" ]] && log_must verify_$subcmd "$histcmd" "$subcmd" \
	"$flags"
	[[ $flags =~ "l" ]] && log_must verify_long "$histcmd" "$user" "$flags"
	}

	function verify_long
	{
	typeset cmd=$1
	typeset user=$2
	typeset flags=$3

	[[ $flags =~ "l" ]] \|\| return 1

	typeset uid=$(id -u $user)
	typeset hname=$(hostname)
	if ! is_global_zone; then
	hname=$hname:$(zonename)
	fi

	typeset suffix=""
	if is_linux; then
	suffix=":linux"
	elif is_freebsd; then
	suffix=":freebsd"
	fi

	grep -q "$cmd \[user $uid ($user) on $hname$suffix\]" $NEW_HISTORY
	if [[ $? != 0 ]]; then
	log_note "Couldn't find long information for \"$cmd\""
	return 1
	fi

	return 0
	}

	function verify_hold
	{
	typeset cmd=$1
	typeset subcmd=$2
	typeset flags=$3

	[[ $flags =~ "i" ]] \|\| return 1

	typeset tag=$(echo $cmd \| awk '{print $4}')
	typeset fullname=${cmd##* }
	typeset dsname=${fullname%%@*}
	typeset snapname=${fullname##*@}

	# This works whether or not the hold was recursive
	for ds in $(zfs list -r -Ho name -t snapshot $dsname \| \
	grep "@$snapname"); do
	grep "$subcmd $ds ([0-9]*) tag=$tag" $NEW_HISTORY \
	>/dev/null 2>&1
	if [[ $? != 0 ]]; then
	log_note "Didn't find hold on $ds with $tag"
	return 1
	fi
	done

	return 0
	}

	function verify_release
	{
	# hold and release formats only differ by the subcommand name, so
	# simply reuse the hold function.
	verify_hold "$1" "release" "$3"
	}

	function verify_rollback
	{
	typeset cmd=$1
	typeset flags=$3

	[[ $flags =~ "i" ]] \|\| return 1

	typeset fullname=${cmd##* }
	typeset dsname=${fullname%%@*}
	typeset parent_fs=${dsname##*/}
	typeset rb_fs=${dsname}/%rollback
	typeset snapname=${fullname##*@}

	grep "clone swap $rb_fs ([0-9]*) parent=$parent_fs" $NEW_HISTORY \
	>/dev/null 2>&1
	if [[ $? != 0 ]]; then
	log_note "Didn't find rollback clone swap in pool history"
	return 1
	fi

	grep "destroy $rb_fs" $NEW_HISTORY >/dev/null 2>&1
	if [[ $? != 0 ]]; then
	log_note "Didn't find rollback destroy in pool history"
	return 1
	fi

	return 0
	}

	function verify_inherit
	{
	typeset cmd=$1
	typeset flags=$3

	[[ $flags =~ "i" ]] \|\| return 1

	typeset dsname=${cmd##* }
	typeset prop=${cmd% *}
	prop=${prop##* }

	# This works whether or not the inherit was recursive
	for ds in $(zfs list -r -Ho name -t filesystem $dsname); do
	grep "$subcmd $ds ([0-9]*) ${prop}=" $NEW_HISTORY >/dev/null \
	2>&1
	if [[ $? != 0 ]]; then
	log_note "Didn't find inherit history for $ds"
	return 1
	fi
	done

	return 0
	}

	function verify_allow
	{
	typeset cmd=$1
	typeset subcmd=$2
	typeset flags=$3

	[[ $flags =~ "i" ]] \|\| return 1
	[[ $subcmd == "allow" ]] && subcmd="update"
	[[ $subcmd == "unallow" ]] && subcmd="remove"
	typeset is_set lflag dflag dsname gname gid uname uid opt str code tmp

	#
	# Here, we determine three things:
	# - Whether we're operating on a set or an individual permission (which
	# dictates the case of the first character in the code)
	# - The name of the dataset we're operating on.
	# - Whether the operation applies locally or to descendent datasets (or
	# both)
	#
	echo $cmd \| awk '{i = NF - 1; print $i}' \| grep '@' >/dev/null \
	2>&1 && is_set=1
	dsname=${cmd##* }
	[[ $cmd =~ "-l " ]] && lflag=1
	[[ $cmd =~ "-d " ]] && dflag=1
	if [[ -z $lflag && -z $dflag ]]; then
	lflag=1
	dflag=1
	fi

	#
	# For each of the five cases below, the operation is essentially the
	# same. First, use the command passed in to determine what the code at
	# the end of the pool history will be. The specifics of the code are
	# described in a block comment at the top of dsl_deleg.c. Once that's
	# been assembled, check for its presence in the history, and return
	# success or failure accordingly.
	#
	if [[ $cmd =~ "-s " ]]; then
	str="s-\$@"
	[[ -n $is_set ]] && str="S-\$@"
	tmp=${cmd#*@}
	code="$str${tmp% *}"
	grep "permission $subcmd $dsname ([0-9]*) $code" \
	$NEW_HISTORY >/dev/null 2>&1
	if [[ $? != 0 ]]; then
	log_note "Couldn't find $code in $NEW_HISTORY"
	return 1
	fi
	elif [[ $cmd =~ "-c " ]]; then
	str="c-\$"
	[[ -n $is_set ]] && str="C-\$"
	tmp=${cmd#*-c}
	code="$str${tmp% *}"
	grep "permission $subcmd $dsname ([0-9]*) $code" \
	$NEW_HISTORY >/dev/null 2>&1
	if [ $? != 0 ]]; then
	log_note "Couldn't find $code in $NEW_HISTORY"
	return 1
	fi
	elif [[ $cmd =~ "-u " ]]; then
	str="u"
	[[ -n $is_set ]] && str="U"
	tmp=${cmd##*-u }
	opt=$(echo $tmp \| awk '{print $2}')
	uid=$(id -u ${tmp%% *})
	if [[ -n $lflag ]]; then
	code="${str}l\$$uid $opt"
	grep "permission $subcmd $dsname ([0-9]*) $code" \
	$NEW_HISTORY >/dev/null 2>&1
	if [ $? != 0 ]]; then
	log_note "Couldn't find $code in $NEW_HISTORY"
	return 1
	fi
	fi
	if [[ -n $dflag ]]; then
	code="${str}d\$$uid $opt"
	grep "permission $subcmd $dsname ([0-9]*) $code" \
	$NEW_HISTORY >/dev/null 2>&1
	if [ $? != 0 ]]; then
	log_note "Couldn't find $code in $NEW_HISTORY"
	return 1
	fi
	fi
	elif [[ $cmd =~ "-g " ]]; then
	str="g"
	[[ -n $is_set ]] && str="G"
	tmp=${cmd##*-g }
	opt=$(echo $tmp \| awk '{print $2}')
	gid=$(awk -F: "/^${tmp%% *}:/ {print \$3}" /etc/group)
	if [[ -n $lflag ]]; then
	code="${str}l\$$gid $opt"
	grep "permission $subcmd $dsname ([0-9]*) $code" \
	$NEW_HISTORY >/dev/null 2>&1
	if [ $? != 0 ]]; then
	log_note "Couldn't find $code in $NEW_HISTORY"
	return 1
	fi
	fi
	if [[ -n $dflag ]]; then
	code="${str}d\$$gid $opt"
	grep "permission $subcmd $dsname ([0-9]*) $code" \
	$NEW_HISTORY >/dev/null 2>&1
	if [ $? != 0 ]]; then
	log_note "Couldn't find $code in $NEW_HISTORY"
	return 1
	fi
	fi
	elif [[ $cmd =~ "-e " ]]; then
	str="e"
	[[ -n $is_set ]] && str="E"
	opt=${cmd##*-e }
	opt=${opt%% *}
	if [[ -n $lflag ]]; then
	code="${str}l\$ $opt"
	grep "permission $subcmd $dsname ([0-9]*) $code" \
	$NEW_HISTORY >/dev/null 2>&1
	if [ $? != 0 ]]; then
	log_note "Couldn't find $code in $NEW_HISTORY"
	return 1
	fi
	fi
	if [[ -n $dflag ]]; then
	code="${str}d\$ $opt"
	grep "permission $subcmd $dsname ([0-9]*) $code" \
	$NEW_HISTORY >/dev/null 2>&1
	if [ $? != 0 ]]; then
	log_note "Couldn't find $code in $NEW_HISTORY"
	return 1
	fi
	fi
	else
	log_note "Can't parse command \"$cmd\""
	return 1
	fi

	return 0
	}

	function verify_unallow
	{
	#
	# The unallow and allow history have the same format, except the former
	# logs "permission removed" and the latter "permission updated" so
	# simply reuse the allow function.
	#
	verify_allow "$1" "unallow" "$3"
	}

	function verify_destroy
	{
	typeset cmd=$1
	typeset flags=$3

	# This function doesn't currently verify the zpool command.
	[[ ${cmd%% *} == "zfs" ]] \|\| return 1
	[[ $flags =~ "i" ]] \|\| return 1

	typeset dsname=${cmd##* }
	[[ $dsname =~ "@" ]] && typeset is_snap=1

	if [[ -n $is_snap ]]; then
	grep "ioctl destroy_snaps" $NEW_HISTORY >/dev/null 2>&1
	if [[ $? != 0 ]]; then
	log_note "Didn't find ioctl while destroying $dsname"
	return 1
	fi
	fi

	# This should be present for datasets and snapshots alike
	grep "destroy $dsname" $NEW_HISTORY >/dev/null 2>&1
	if [[ $? != 0 ]]; then
	log_note "Didn't find \"destroy\" for $dsname"
	return 1
	fi

	return 0
	}

	function verify_snapshot
	{
	typeset cmd=$1
	typeset flags=$3

	[[ $flags =~ "i" ]] \|\| return 1

	typeset fullname=${cmd##* }
	typeset dsname=${fullname%%@*}
	typeset snapname=${fullname##*@}

	grep "\[txg:[0-9]\] $subcmd $fullname ([0-9])" $NEW_HISTORY \
	>/dev/null 2>&1
	if [[ $? != 0 ]]; then
	log_note "Didn't find snapshot command for $fullname"
	return 1
	fi

	# This works whether or not the snapshot was recursive
	for ds in $(zfs list -r -Ho name -t snapshot $dsname \| \
	grep "@$snapname"); do
	grep "^[ ]* $ds$" $NEW_HISTORY >/dev/null 2>&1
	if [[ $? != 0 ]]; then
	log_note "Didn't find \"ioctl snapshot\" for $ds"
	return 1
	fi
	done

	return 0
	}
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/largest_pool/largest_pool_001_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/largest_pool/largest_pool_001_pos.ksh
	index a8934159b244..6b51598d7cca 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/largest_pool/largest_pool_001_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/largest_pool/largest_pool_001_pos.ksh
	@@ -1,161 +1,161 @@
	#!/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/largest_pool/largest_pool.cfg

	# DESCRIPTION:
	# The largest pool can be created and a dataset in that
	# pool can be created and mounted.
	#
	# STRATEGY:
	# create a pool which will contain a volume device.
	# create a volume device of desired sizes.
	# create the largest pool allowed using the volume vdev.
	# create and mount a dataset in the largest pool.
	# create some files in the zfs file system.
	# do some zpool list commands and parse the output.

	verify_runnable "global"

	#
	# Parse the results of zpool & zfs creation with specified size
	#
	# $1: volume size
	#
	# return value:
	# 0 -> success
	# 1 -> failure
	#
	function parse_expected_output
	{
	UNITS=`echo $1 \| sed -e 's/^$[0-9].*$$[a-z].$/\2/'`
	case "$UNITS" in
	'mb') CHKUNIT="M" ;;
	'gb') CHKUNIT="G" ;;
	'tb') CHKUNIT="T" ;;
	'pb') CHKUNIT="P" ;;
	'eb') CHKUNIT="E" ;;
	*) CHKUNIT="M" ;;
	esac

	log_note "Detect zpool $TESTPOOL in this test machine."
	log_must eval "zpool list $TESTPOOL > $TEST_BASE_DIR/j.$$"
	log_must eval "grep $TESTPOOL $TEST_BASE_DIR/j.$$ \| \
	awk '{print $2}' \| grep $CHKUNIT"

	log_note "Detect the file system in this test machine."
	log_must eval "df -F zfs -h > $TEST_BASE_DIR/j.$$"
	log_must eval "grep $TESTPOOL $TEST_BASE_DIR/j.$$ \| \
	awk '{print $2}' \| grep $CHKUNIT"

	return 0
	}

	#
	# Check and destroy zfs, volume & zpool remove the temporary files
	#
	function cleanup
	{
	log_note "Start cleanup the zfs and pool"

	if datasetexists $TESTPOOL/$TESTFS ; then
	if ismounted $TESTPOOL/$TESTFS ; then
	log_must zfs unmount $TESTPOOL/$TESTFS
	fi
	- log_must zfs destroy $TESTPOOL/$TESTFS
	+ destroy_dataset $TESTPOOL/$TESTFS
	fi

	destroy_pool $TESTPOOL

	datasetexists $TESTPOOL2/$TESTVOL && \
	- log_must zfs destroy $TESTPOOL2/$TESTVOL
	+ destroy_dataset $TESTPOOL2/$TESTVOL

	destroy_pool $TESTPOOL2

	rm -f $TEST_BASE_DIR/j.* > /dev/null
	}

	log_assert "The largest pool can be created and a dataset in that" \
	"pool can be created and mounted."

	# Set trigger. When the test case exit, cleanup is executed.
	log_onexit cleanup

	# -----------------------------------------------------------------------
	# volume sizes with unit designations.
	#
	# Note: specifying the number '1' as size will not give the correct
	# units for 'df'. It must be greater than one.
	# -----------------------------------------------------------------------
	typeset str
	typeset -i ret
	for volsize in $VOLSIZES; do
	log_note "Create a pool which will contain a volume device"
	create_pool $TESTPOOL2 "$DISKS"

	log_note "Create a volume device of desired sizes: $volsize"
	str=$(zfs create -sV $volsize $TESTPOOL2/$TESTVOL 2>&1)
	ret=$?
	if (( ret != 0 )); then
	if [[ is_32bit && \
	$str == ${VOL_LIMIT_KEYWORD1} \|\| \
	$str == ${VOL_LIMIT_KEYWORD2} \|\| \
	$str == ${VOL_LIMIT_KEYWORD3} ]]
	then
	log_unsupported \
	"Max volume size is 1TB on 32-bit systems."
	else
	log_fail "zfs create -sV $volsize $TESTPOOL2/$TESTVOL"
	fi
	fi
	block_device_wait

	log_note "Create the largest pool allowed using the volume vdev"
	create_pool $TESTPOOL "$VOL_PATH"

	log_note "Create a zfs file system in the largest pool"
	log_must zfs create $TESTPOOL/$TESTFS

	log_note "Parse the execution result"
	parse_expected_output $volsize

	log_note "unmount this zfs file system $TESTPOOL/$TESTFS"
	log_must zfs unmount $TESTPOOL/$TESTFS

	log_note "Destroy zfs, volume & zpool"
	log_must zfs destroy $TESTPOOL/$TESTFS
	destroy_pool $TESTPOOL
	- log_must zfs destroy $TESTPOOL2/$TESTVOL
	+ log_must_busy zfs destroy $TESTPOOL2/$TESTVOL
	destroy_pool $TESTPOOL2
	done

	log_pass "Dataset can be created, mounted & destroy in largest pool succeeded."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/mmap/Makefile.am b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/mmap/Makefile.am
	index 2adc398b8c09..b26791ee7ce0 100644
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/mmap/Makefile.am
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/mmap/Makefile.am
	@@ -1,10 +1,11 @@
	pkgdatadir = $(datadir)/@PACKAGE@/zfs-tests/tests/functional/mmap
	dist_pkgdata_SCRIPTS = \
	setup.ksh \
	cleanup.ksh \
	mmap_read_001_pos.ksh \
	mmap_write_001_pos.ksh \
	- mmap_libaio_001_pos.ksh
	+ mmap_libaio_001_pos.ksh \
	+ mmap_seek_001_pos.ksh

	dist_pkgdata_DATA = \
	mmap.cfg
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/mmap/mmap_seek_001_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/mmap/mmap_seek_001_pos.ksh
	new file mode 100755
	index 000000000000..6188549ad8d2
	--- /dev/null
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/mmap/mmap_seek_001_pos.ksh
	@@ -0,0 +1,67 @@
	+#!/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) 2021 by Lawrence Livermore National Security, LLC.
	+#
	+
	+. $STF_SUITE/include/libtest.shlib
	+. $STF_SUITE/tests/functional/mmap/mmap.cfg
	+
	+#
	+# DESCRIPTION:
	+# lseek() data/holes for an mmap()'d file.
	+#
	+# STRATEGY:
	+# 1. Enable compression and hole reporting for dirty files.
	+# 2. Call mmap_seek binary test case for various record sizes.
	+#
	+
	+verify_runnable "global"
	+
	+function cleanup
	+{
	+ log_must zfs set compression=off $TESTPOOL/$TESTFS
	+ log_must zfs set recordsize=128k $TESTPOOL/$TESTFS
	+ log_must rm -f $TESTDIR/test-mmap-file
	+ log_must set_tunable64 DMU_OFFSET_NEXT_SYNC $dmu_offset_next_sync
	+}
	+
	+log_assert "lseek() data/holes for an mmap()'d file."
	+
	+log_onexit cleanup
	+
	+# Enable hole reporting for dirty files.
	+typeset dmu_offset_next_sync=$(get_tunable DMU_OFFSET_NEXT_SYNC)
	+log_must set_tunable64 DMU_OFFSET_NEXT_SYNC 1
	+
	+# Compression must be enabled to convert zero'd blocks to holes.
	+# This behavior is checked by the mmap_seek test.
	+log_must zfs set compression=on $TESTPOOL/$TESTFS
	+
	+for bs in 4096 8192 16384 32768 65536 131072; do
	+ log_must zfs set recordsize=$bs $TESTPOOL/$TESTFS
	+ log_must mmap_seek $TESTDIR/test-mmap-file $((1024*1024)) $bs
	+ log_must rm $TESTDIR/test-mmap-file
	+done
	+
	+log_pass "lseek() data/holes for an mmap()'d file succeeded."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/nopwrite/nopwrite_copies.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/nopwrite/nopwrite_copies.ksh
	index 3971820966f1..2a61f605b21d 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/nopwrite/nopwrite_copies.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/nopwrite/nopwrite_copies.ksh
	@@ -1,71 +1,71 @@
	#!/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.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/nopwrite/nopwrite.shlib

	#
	# Description:
	# Verify that nopwrite is not enabled if the copies property changes
	#
	# Strategy:
	# 1. Create a clone with copies set higher than the origin fs
	# 2. Verify that nopwrite is in use.
	# 3. Repeat with the number of copies decreased.
	#

	verify_runnable "global"
	origin="$TESTPOOL/$TESTFS"
	log_onexit cleanup

	function cleanup
	{
	- datasetexists $origin && log_must zfs destroy -R $origin
	+ datasetexists $origin && destroy_dataset $origin -R
	log_must zfs create -o mountpoint=$TESTDIR $origin
	}

	log_assert "nopwrite requires copies property to remain constant"

	# Verify nopwrite is disabled with increased redundancy
	log_must zfs set compress=on $origin
	log_must zfs set checksum=sha256 $origin
	dd if=/dev/urandom of=$TESTDIR/file bs=1024k count=$MEGS conv=notrunc \
	>/dev/null 2>&1 \|\| log_fail "dd into $TESTDIR/file failed."
	zfs snapshot $origin@a \|\| log_fail "zfs snap failed"
	log_must zfs clone $origin@a $origin/clone
	zfs set copies=3 $origin/clone
	dd if=/$TESTDIR/file of=/$TESTDIR/clone/file bs=1024k count=$MEGS \
	conv=notrunc >/dev/null 2>&1 \|\| log_fail "dd failed."
	log_mustnot verify_nopwrite $origin $origin@a $origin/clone

	# Verify nopwrite is disabled with decreased redundancy
	zfs destroy -R $origin \|\| log_fail "Couldn't destroy $origin"
	zfs create -o mountpoint=$TESTDIR $origin \|\| \
	log_fail "Couldn't recreate $origin"
	log_must zfs set compress=on $origin
	log_must zfs set copies=3 $origin
	log_must zfs set checksum=sha256 $origin
	dd if=/dev/urandom of=$TESTDIR/file bs=1024k count=$MEGS conv=notrunc \
	>/dev/null 2>&1 \|\| log_fail "dd into $TESTDIR/file failed."
	zfs snapshot $origin@a \|\| log_fail "zfs snap failed"
	log_must zfs clone $origin@a $origin/clone
	zfs set copies=1 $origin/clone
	dd if=/$TESTDIR/file of=/$TESTDIR/clone/file bs=1024k count=$MEGS \
	conv=notrunc >/dev/null 2>&1 \|\| log_fail "dd failed."
	log_mustnot verify_nopwrite $origin $origin@a $origin/clone

	log_pass "nopwrite requires copies property to remain constant"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/nopwrite/nopwrite_mtime.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/nopwrite/nopwrite_mtime.ksh
	index 039b661e2fb9..0422bbaca1c8 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/nopwrite/nopwrite_mtime.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/nopwrite/nopwrite_mtime.ksh
	@@ -1,89 +1,89 @@
	#!/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.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/nopwrite/nopwrite.shlib

	#
	# Description:
	# Verify that nopwrite still updates file metadata correctly
	#
	# Strategy:
	# 1. Create a clone with nopwrite enabled.
	# 2. Write to the file in that clone and verify the mtime and ctime change,
	# but the atime does not.
	#

	verify_runnable "global"
	origin="$TESTPOOL/$TESTFS"
	log_onexit cleanup

	function cleanup
	{
	- datasetexists $origin && log_must zfs destroy -R $origin
	+ datasetexists $origin && destroy_dataset $origin -R
	log_must zfs create -o mountpoint=$TESTDIR $origin
	}

	log_assert "nopwrite updates file metadata correctly"

	log_must zfs set compress=on $origin
	log_must zfs set checksum=sha256 $origin
	dd if=/dev/urandom of=$TESTDIR/file bs=1024k count=$MEGS conv=notrunc \
	>/dev/null 2>&1 \|\| log_fail "dd into $TESTDIR/file failed."
	zfs snapshot $origin@a \|\| log_fail "zfs snap failed"
	log_must zfs clone $origin@a $origin/clone

	if is_linux; then
	o_atime=$(stat -c %X $TESTDIR/clone/file)
	o_ctime=$(stat -c %Z $TESTDIR/clone/file)
	o_mtime=$(stat -c %Y $TESTDIR/clone/file)
	elif is_freebsd; then
	o_atime=$(stat -f "%a" $TESTDIR/clone/file)
	o_ctime=$(stat -f "%c" $TESTDIR/clone/file)
	o_mtime=$(stat -f "%m" $TESTDIR/clone/file)
	else
	o_atime=$(ls -E% all $TESTDIR/clone/file \| awk '/atime/ {print $4}')
	o_ctime=$(ls -E% all $TESTDIR/clone/file \| awk '/ctime/ {print $4}')
	o_mtime=$(ls -E% all $TESTDIR/clone/file \| awk '/mtime/ {print $4}')
	fi

	sleep 1
	dd if=/$TESTDIR/file of=/$TESTDIR/clone/file bs=1024k count=$MEGS \
	conv=notrunc >/dev/null 2>&1 \|\| log_fail "dd failed."
	sleep 1

	if is_linux; then
	atime=$(stat -c %X $TESTDIR/clone/file)
	ctime=$(stat -c %Z $TESTDIR/clone/file)
	mtime=$(stat -c %Y $TESTDIR/clone/file)
	elif is_freebsd; then
	atime=$(stat -f "%a" $TESTDIR/clone/file)
	ctime=$(stat -f "%c" $TESTDIR/clone/file)
	mtime=$(stat -f "%m" $TESTDIR/clone/file)
	else
	atime=$(ls -E% all $TESTDIR/clone/file \| awk '/atime/ {print $4}')
	ctime=$(ls -E% all $TESTDIR/clone/file \| awk '/ctime/ {print $4}')
	mtime=$(ls -E% all $TESTDIR/clone/file \| awk '/mtime/ {print $4}')
	fi

	[[ $o_atime = $atime ]] \|\| log_fail "atime changed: $o_atime $atime"
	[[ $o_ctime = $ctime ]] && log_fail "ctime unchanged: $o_ctime $ctime"
	[[ $o_mtime = $mtime ]] && log_fail "mtime unchanged: $o_mtime $mtime"

	log_must verify_nopwrite $origin $origin@a $origin/clone

	log_pass "nopwrite updates file metadata correctly"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/nopwrite/nopwrite_negative.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/nopwrite/nopwrite_negative.ksh
	index 8b0b9b549920..617c34602beb 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/nopwrite/nopwrite_negative.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/nopwrite/nopwrite_negative.ksh
	@@ -1,90 +1,90 @@
	#!/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.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/nopwrite/nopwrite.shlib

	#
	# Description:
	# Verify that duplicate writes to a clone are accounted as new data if the
	# prerequisites for nopwrite are not met.
	#
	# Scenarios:
	# 1. The file in the origin ds is written without compression or sha256.
	# 2. The file in the origin ds is written before sha256 checksum is turned on.
	# 3. The clone does not have compression.
	# 4. The clone does not have the appropriate checksum.
	#

	verify_runnable "global"
	origin="$TESTPOOL/$TESTFS"
	log_onexit cleanup

	function cleanup
	{
	- datasetexists $origin && log_must zfs destroy -R $origin
	+ datasetexists $origin && destroy_dataset $origin -R
	log_must zfs create -o mountpoint=$TESTDIR $origin
	}

	log_assert "nopwrite isn't enabled without the prerequisites"

	# Data written into origin fs without compression or sha256
	dd if=/dev/urandom of=$TESTDIR/file bs=1024k count=$MEGS conv=notrunc \
	>/dev/null 2>&1 \|\| log_fail "dd of $TESTDIR/file failed."
	zfs snapshot $origin@a \|\| log_fail "zfs snap failed"
	log_must zfs clone -o compress=on $origin@a $origin/clone
	log_must zfs set checksum=sha256 $origin/clone
	dd if=/$TESTDIR/file of=/$TESTDIR/clone/file bs=1024k count=$MEGS \
	conv=notrunc >/dev/null 2>&1 \|\| log_fail "dd failed."
	log_mustnot verify_nopwrite $origin $origin@a $origin/clone
	zfs destroy -R $origin@a \|\| log_fail "zfs destroy failed"
	log_must rm -f $TESTDIR/file

	# Data written to origin fs before checksum enabled
	log_must zfs set compress=on $origin
	dd if=/dev/urandom of=$TESTDIR/file bs=1024k count=$MEGS conv=notrunc \
	>/dev/null 2>&1 \|\| log_fail "dd into $TESTDIR/file failed."
	log_must zfs set checksum=sha256 $origin
	zfs snapshot $origin@a \|\| log_fail "zfs snap failed"
	log_must zfs clone $origin@a $origin/clone
	dd if=/$TESTDIR/file of=/$TESTDIR/clone/file bs=1024k count=$MEGS \
	conv=notrunc >/dev/null 2>&1 \|\| log_fail "dd failed."
	log_mustnot verify_nopwrite $origin $origin@a $origin/clone
	zfs destroy -R $origin@a \|\| log_fail "zfs destroy failed"
	log_must rm -f $TESTDIR/file

	# Clone with compression=off
	dd if=/dev/urandom of=$TESTDIR/file bs=1024k count=$MEGS conv=notrunc \
	>/dev/null 2>&1 \|\| log_fail "dd into $TESTDIR/file failed."
	zfs snapshot $origin@a \|\| log_fail "zfs snap failed"
	log_must zfs clone -o compress=off $origin@a $origin/clone
	dd if=/$TESTDIR/file of=/$TESTDIR/clone/file bs=1024k count=$MEGS \
	conv=notrunc >/dev/null 2>&1 \|\| log_fail "dd failed."
	log_mustnot verify_nopwrite $origin $origin@a $origin/clone
	zfs destroy -R $origin@a \|\| log_fail "zfs destroy failed"
	log_must rm -f $TESTDIR/file

	# Clone with fletcher4, rather than sha256
	dd if=/dev/urandom of=$TESTDIR/file bs=1024k count=$MEGS conv=notrunc \
	>/dev/null 2>&1 \|\| log_fail "dd into $TESTDIR/file failed."
	zfs snapshot $origin@a \|\| log_fail "zfs snap failed"
	log_must zfs clone -o checksum=fletcher4 $origin@a $origin/clone
	dd if=/$TESTDIR/file of=/$TESTDIR/clone/file bs=1024k count=$MEGS \
	conv=notrunc >/dev/null 2>&1 \|\| log_fail "dd failed."
	log_mustnot verify_nopwrite $origin $origin@a $origin/clone

	log_pass "nopwrite isn't enabled without the prerequisites"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/nopwrite/nopwrite_promoted_clone.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/nopwrite/nopwrite_promoted_clone.ksh
	index f9e6e83b7a8d..057c59a3801c 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/nopwrite/nopwrite_promoted_clone.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/nopwrite/nopwrite_promoted_clone.ksh
	@@ -1,58 +1,58 @@
	#!/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.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/nopwrite/nopwrite.shlib

	#
	# Description:
	# Verify that nopwrite still works for a dataset that becomes a clone via
	# promotion.
	#
	# Strategy:
	# 1. Create a clone suitable for nopwrite.
	# 2. Disable compression and checksum on the clone, and promote it.
	# 3. Overwrite the file in the clone (former origin fs) and verify it
	# consumes no additional space.
	#

	verify_runnable "global"
	origin="$TESTPOOL/$TESTFS"
	log_onexit cleanup

	function cleanup
	{
	- datasetexists $origin && log_must zfs destroy -R $TESTPOOL/clone
	+ datasetexists $origin && destroy_dataset $TESTPOOL/clone -R
	log_must zfs create -o mountpoint=$TESTDIR $origin
	}

	log_assert "nopwrite works on a dataset that becomes a clone via promotion."

	log_must zfs set compress=on $origin
	log_must zfs set checksum=sha256 $origin
	dd if=/dev/urandom of=$TESTDIR/file bs=1024k count=$MEGS conv=notrunc \
	>/dev/null 2>&1 \|\| log_fail "dd into $TESTDIR/file failed."
	zfs snapshot $origin@a \|\| log_fail "zfs snap failed"
	log_must zfs clone $origin@a $TESTPOOL/clone
	log_must zfs set compress=off $TESTPOOL/clone
	log_must zfs set checksum=off $TESTPOOL/clone
	log_must zfs promote $TESTPOOL/clone
	dd if=/$TESTPOOL/clone/file of=/$TESTDIR/file bs=1024k count=$MEGS \
	conv=notrunc >/dev/null 2>&1 \|\| log_fail "dd failed."
	log_must verify_nopwrite $TESTPOOL/clone $TESTPOOL/clone@a $origin

	log_pass "nopwrite works on a dataset that becomes a clone via promotion."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/nopwrite/nopwrite_recsize.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/nopwrite/nopwrite_recsize.ksh
	index 205b3357d8d0..38e7ec1ff219 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/nopwrite/nopwrite_recsize.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/nopwrite/nopwrite_recsize.ksh
	@@ -1,57 +1,57 @@
	#!/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.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/nopwrite/nopwrite.shlib

	#
	# Description:
	# Verify that nopwrite works regardless of recsize property setting.
	#
	# Strategy:
	# 1. Create an origin fs that's suitable to make nopwrite clones.
	# 2. For each possible recsize, create a clone that inherits the compress and
	# checksum, and verify overwriting the origin file consumes no new space.
	#

	verify_runnable "global"
	origin="$TESTPOOL/$TESTFS"
	log_onexit cleanup

	function cleanup
	{
	- datasetexists $origin && log_must zfs destroy -R $origin
	+ datasetexists $origin && destroy_dataset $origin -R
	log_must zfs create -o mountpoint=$TESTDIR $origin
	}

	log_assert "nopwrite updates file metadata correctly"

	log_must zfs set compress=on $origin
	log_must zfs set checksum=sha256 $origin
	dd if=/dev/urandom of=$TESTDIR/file bs=1024k count=$MEGS conv=notrunc \
	>/dev/null 2>&1 \|\| log_fail "dd into $TESTDIR/file failed."
	zfs snapshot $origin@a \|\| log_fail "zfs snap failed"
	log_must zfs clone $origin@a $origin/clone

	for rs in 512 1024 2048 4096 8192 16384 32768 65536 131072 ; do
	log_must zfs set recsize=$rs $origin/clone
	dd if=/$TESTDIR/file of=/$TESTDIR/clone/file bs=1024k count=$MEGS \
	conv=notrunc >/dev/null 2>&1 \|\| log_fail "dd failed."
	log_must verify_nopwrite $origin $origin@a $origin/clone
	done

	log_pass "nopwrite updates file metadata correctly"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/nopwrite/nopwrite_sync.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/nopwrite/nopwrite_sync.ksh
	index bd38883d7578..e0721cac198c 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/nopwrite/nopwrite_sync.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/nopwrite/nopwrite_sync.ksh
	@@ -1,55 +1,55 @@
	#!/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.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/nopwrite/nopwrite.shlib

	#
	# Description:
	# Verify that nopwrite works for sync writes
	#
	# Strategy:
	# 1. Create an origin fs with compression and sha256.
	# 2. Clone origin such that it inherits the properties.
	# 3. Use dd with the sync flag to test the sync write path.
	#

	verify_runnable "global"
	origin="$TESTPOOL/$TESTFS"
	log_onexit cleanup

	function cleanup
	{
	- datasetexists $origin && log_must zfs destroy -R $origin
	+ datasetexists $origin && destroy_dataset $origin -R
	log_must zfs create -o mountpoint=$TESTDIR $origin
	}

	log_assert "nopwrite works for sync writes"

	log_must zfs set compress=on $origin
	log_must zfs set checksum=sha256 $origin
	dd if=/dev/urandom of=$TESTDIR/file bs=1024k count=$MEGS oflag=sync \
	conv=notrunc >/dev/null 2>&1 \|\| log_fail "dd into $TESTDIR/file failed."
	zfs snapshot $origin@a \|\| log_fail "zfs snap failed"
	log_must zfs clone $origin@a $origin/clone

	dd if=/$TESTDIR/file of=/$TESTDIR/clone/file bs=1024k count=$MEGS \
	oflag=sync conv=notrunc >/dev/null 2>&1 \|\| log_fail "dd failed."

	log_must verify_nopwrite $origin $origin@a $origin/clone

	log_pass "nopwrite works for sync writes"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/nopwrite/nopwrite_varying_compression.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/nopwrite/nopwrite_varying_compression.ksh
	index d256876a9c45..190bdbd6c6db 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/nopwrite/nopwrite_varying_compression.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/nopwrite/nopwrite_varying_compression.ksh
	@@ -1,65 +1,65 @@
	#!/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, Delphix. All rights reserved.
	# Copyright (c) 2019, Kjeld Schouten-Lebbing. All Rights Reserved.
	#

	. $STF_SUITE/include/properties.shlib
	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/nopwrite/nopwrite.shlib

	#
	# Description:
	# Verify that if the checksum on the origin and clone is sha256, any compression
	# algorithm enables nopwrite.
	#
	# Strategy:
	# 1. Create an origin dataset with compression and sha256 checksum.
	# 2. Write a 64M file into the origin dataset.
	# 3. For each of 4 randomly chosen compression types:
	# 3a. Create a snap and clone (inheriting the checksum property) of the origin.
	# 3b. Apply the compression property to the clone.
	# 3c. Write the same 64M of data into the file that exists in the clone.
	# 3d. Verify that no new space was consumed.
	#

	verify_runnable "global"
	origin="$TESTPOOL/$TESTFS"
	log_onexit cleanup

	function cleanup
	{
	- datasetexists $origin && log_must zfs destroy -R $origin
	+ datasetexists $origin && destroy_dataset $origin -R
	log_must zfs create -o mountpoint=$TESTDIR $origin
	}

	log_assert "nopwrite works with sha256 and any compression algorithm"

	log_must zfs set compress=on $origin
	log_must zfs set checksum=sha256 $origin
	dd if=/dev/urandom of=$TESTDIR/file bs=1024k count=$MEGS conv=notrunc \
	>/dev/null 2>&1 \|\| log_fail "initial dd failed."

	# Verify nop_write for all compression algorithms except "off"
	for i in "${compress_prop_vals[@]:1}"; do
	zfs snapshot $origin@a \|\| log_fail "zfs snap failed"
	log_must zfs clone -o compress=$i $origin@a $origin/clone
	dd if=/$TESTDIR/file of=/$TESTDIR/clone/file bs=1024k count=$MEGS \
	conv=notrunc >/dev/null 2>&1 \|\| log_fail "dd failed."
	log_must verify_nopwrite $origin $origin@a $origin/clone
	zfs destroy -R $origin@a \|\| log_fail "zfs destroy failed"
	done

	log_pass "nopwrite works with sha256 and any compression algorithm"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/nopwrite/nopwrite_volume.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/nopwrite/nopwrite_volume.ksh
	index a118b982240c..1efe0b772868 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/nopwrite/nopwrite_volume.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/nopwrite/nopwrite_volume.ksh
	@@ -1,59 +1,59 @@
	#!/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.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/nopwrite/nopwrite.shlib

	#
	# Description:
	# Verify that nopwrite cannot be enabled on volumes
	#
	# Strategy:
	# 1. Create a clone of a volume that fits the criteria for nopwrite.
	# 2. Overwrite the same blocks from the origin vol and verify that
	# new space is consumed.
	#

	verify_runnable "global"
	origin="$TESTPOOL/$TESTVOL"
	clone="$TESTPOOL/clone"
	vol="${ZVOL_RDEVDIR}/$origin"
	volclone="${ZVOL_RDEVDIR}/$clone"
	log_onexit cleanup

	function cleanup
	{
	- datasetexists $origin && log_must zfs destroy -R $origin
	+ datasetexists $origin && destroy_dataset $origin -R
	# No need to recreate the volume as no other tests expect it.
	}

	log_assert "nopwrite works on volumes"

	log_must zfs set compress=on $origin
	log_must zfs set checksum=sha256 $origin
	dd if=/dev/urandom of=$vol bs=8192 count=4096 conv=notrunc >/dev/null \
	2>&1 \|\| log_fail "dd into $origin failed."
	zfs snapshot $origin@a \|\| log_fail "zfs snap failed"
	log_must zfs clone $origin@a $clone
	log_must zfs set compress=on $clone
	log_must zfs set checksum=sha256 $clone
	block_device_wait
	dd if=$vol of=$volclone bs=8192 count=4096 conv=notrunc >/dev/null 2>&1 \|\| \
	log_fail "dd into $clone failed."
	log_must verify_nopwrite $origin $origin@a $clone

	log_pass "nopwrite works on volumes"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/procfs/procfs_list_basic.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/procfs/procfs_list_basic.ksh
	index 88911aac6e8e..dfc1f1ee0497 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/procfs/procfs_list_basic.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/procfs/procfs_list_basic.ksh
	@@ -1,95 +1,95 @@
	#!/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 Delphix. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib

	#
	# DESCRIPTION:
	# Test that we can read from and write to a file in procfs whose contents is
	# backed by a linked list.
	#
	# STRATEGY:
	# 1. Take some snapshots of a filesystem, which will cause some messages to be
	# written to the zfs dbgmsgs.
	# 2. Read the dbgmsgs via procfs and verify that the expected messages are
	# present.
	# 3. Write to the dbgmsgs file to clear the messages.
	# 4. Read the dbgmsgs again, and make sure the messages are no longer present.
	#

	function cleanup
	{
	- datasetexists $FS && log_must zfs destroy -r $FS
	+ datasetexists $FS && destroy_dataset $FS -r
	}

	function count_snap_cmds
	{
	typeset expected_count=$1
	count=$(grep -E "command: (lt-)?zfs snapshot $FS@testsnapshot" \| wc -l)
	log_must eval "[[ $count -eq $expected_count ]]"
	}

	typeset -r ZFS_DBGMSG=/proc/spl/kstat/zfs/dbgmsg
	typeset -r FS=$TESTPOOL/fs
	typeset snap_msgs

	log_onexit cleanup

	# Clear out old messages
	echo 0 >$ZFS_DBGMSG \|\| log_fail "failed to write to $ZFS_DBGMSG"

	log_must zfs create $FS
	for i in {1..20}; do
	log_must zfs snapshot "$FS@testsnapshot$i"
	done
	log_must zpool sync $TESTPOOL

	#
	# Read the debug message file in small chunks to make sure that the read is
	# split up into multiple syscalls. This tests that when a syscall begins we
	# correctly pick up in the list of messages where the previous syscall left
	# off. The size of the read can affect how many bytes the seq_file code has
	# left in its internal buffer, which in turn can affect the relative pos that
	# the seq_file code picks up at when the next read starts. Try a few
	# different size reads to make sure we can handle each case.
	#
	# Check that the file has the right contents by grepping for some of the
	# messages that we expect to be present.
	#
	for chunk_sz in {1,64,256,1024,4096}; do
	dd if=$ZFS_DBGMSG bs=$chunk_sz \| count_snap_cmds 20
	done

	# Clear out old messages and check that they really are gone
	echo 0 >$ZFS_DBGMSG \|\| log_fail "failed to write to $ZFS_DBGMSG"
	cat $ZFS_DBGMSG \| count_snap_cmds 0
	#
	# Even though we don't expect any messages in the file, reading should still
	# succeed.
	#
	log_must cat $ZFS_DBGMSG

	log_pass "Basic reading/writing of procfs file backed by linked list successful"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/procfs/procfs_list_concurrent_readers.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/procfs/procfs_list_concurrent_readers.ksh
	index 6ca7fd7d6f42..1af1c2c07089 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/procfs/procfs_list_concurrent_readers.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/procfs/procfs_list_concurrent_readers.ksh
	@@ -1,82 +1,82 @@
	#!/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 Delphix. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib

	#
	# DESCRIPTION:
	# Make sure that interleaving reads from different readers does not affect the
	# results that are returned.
	#
	# STRATEGY:
	# 1. Make sure a few debug messages have been logged.
	# 2. Open the procfs file and start reading from it.
	# 3. Open the file again, and read its entire contents.
	# 4. Resume reading from the first instance.
	# 5. Check that the contents read by the two instances are identical.
	#

	function cleanup
	{
	[[ -z $msgs1 ]] \|\| log_must rm $msgs1
	[[ -z $msgs2 ]] \|\| log_must rm $msgs2
	- datasetexists $FS && log_must zfs destroy -r $FS
	+ datasetexists $FS && destroy_dataset $FS -r
	}

	typeset -r ZFS_DBGMSG=/proc/spl/kstat/zfs/dbgmsg
	typeset -r FS=$TESTPOOL/fs
	typeset msgs1 msgs2

	log_onexit cleanup

	# Clear out old messages
	echo 0 >$ZFS_DBGMSG \|\| log_fail "failed to write to $ZFS_DBGMSG"

	# Add some new messages
	log_must zfs create $FS
	for i in {1..20}; do
	log_must zfs snapshot "$FS@testsnapshot$i"
	done
	log_must zpool sync $TESTPOOL

	msgs1=$(mktemp) \|\| log_fail
	msgs2=$(mktemp) \|\| log_fail

	#
	# Start reading file, pause and read it from another process, and then finish
	# reading.
	#
	{ dd bs=512 count=4; cat $ZFS_DBGMSG >$msgs1; cat; } <$ZFS_DBGMSG >$msgs2

	#
	# Truncate the result of the read that completed second in case it picked up an
	# extra message that was logged after the first read completed.
	#
	log_must truncate -s $(stat_size $msgs1) $msgs2

	log_must diff $msgs1 $msgs2

	log_pass "Concurrent readers receive identical results"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/projectquota/projectquota_004_neg.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/projectquota/projectquota_004_neg.ksh
	index a975d2a19f0c..7ca81c3fbc81 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/projectquota/projectquota_004_neg.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/projectquota/projectquota_004_neg.ksh
	@@ -1,87 +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 2009 Sun Microsystems, Inc. All rights reserved.
	# Use is subject to license terms.
	#

	#
	# Copyright (c) 2017 by Fan Yong. All rights reserved.
	#

	. $STF_SUITE/tests/functional/projectquota/projectquota_common.kshlib

	#
	# DESCRIPTION:
	# Check the invalid parameter of zfs set project{obj}quota
	#
	#
	# STRATEGY:
	# 1. check the invalid zfs set project{obj}quota to fs
	# 2. check the valid zfs set project{obj}quota to snapshots
	#

	function cleanup
	{
	- if datasetexists $snap_fs; then
	- log_must zfs destroy $snap_fs
	- fi
	+ datasetexists $snap_fs && destroy_dataset $snap_fs

	log_must cleanup_projectquota
	}

	log_onexit cleanup

	log_assert "Check the invalid parameter of zfs set project{obj}quota"
	typeset snap_fs=$QFS@snap

	log_must zfs snapshot $snap_fs

	set -A no_prjs "mms1234" "ss@#" "root-122" "-1"
	for prj in "${no_prjs[@]}"; do
	log_mustnot zfs set projectquota@$prj=100m $QFS
	done

	log_note "can set all numeric id even if that id does not exist"
	log_must zfs set projectquota@12345678=100m $QFS

	set -A sizes "100mfsd" "m0.12m" "GGM" "-1234-m" "123m-m"
	for size in "${sizes[@]}"; do
	log_note "can not set projectquota with invalid size parameter"
	log_mustnot zfs set projectquota@$PRJID1=$size $QFS
	done

	log_note "can not set projectquota to snapshot $snap_fs"
	log_mustnot zfs set projectquota@$PRJID1=100m $snap_fs

	for prj in "${no_prjs[@]}"; do
	log_mustnot zfs set projectobjquota@$prj=100 $QFS
	done

	log_note "can not set projectobjquota with invalid size parameter"
	log_mustnot zfs set projectobjquota@$PRJID2=100msfsd $QFS

	log_note "can not set projectobjquota to snapshot $snap_fs"
	log_mustnot zfs set projectobjquota@$PRJID2=100m $snap_fs

	log_pass "Check the invalid parameter of zfs set project{obj}quota"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/projectquota/projectquota_005_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/projectquota/projectquota_005_pos.ksh
	index b52f302f7892..0736648f1ed6 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/projectquota/projectquota_005_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/projectquota/projectquota_005_pos.ksh
	@@ -1,68 +1,66 @@
	#!/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) 2017 by Fan Yong. All rights reserved.
	#

	. $STF_SUITE/tests/functional/projectquota/projectquota_common.kshlib

	#
	# DESCRIPTION:
	# Check the invalid parameter of zfs get project{obj}quota
	#
	#
	# STRATEGY:
	# 1. check the invalid zfs get project{obj}quota to fs
	# 2. check the valid zfs get project{obj}quota to snapshots
	#

	function cleanup
	{
	- if datasetexists $snap_fs; then
	- log_must zfs destroy $snap_fs
	- fi
	+ datasetexists $snap_fs && destroy_dataset $snap_fs

	log_must cleanup_projectquota
	}

	log_onexit cleanup

	log_assert "Check the invalid parameter of zfs get project{obj}quota"
	typeset snap_fs=$QFS@snap

	log_must zfs snapshot $snap_fs

	set -A no_prjs "mms1234" "ss@#" "root-122"
	for prj in "${no_prjs[@]}"; do
	log_must eval "zfs get projectquota@$prj $QFS >/dev/null 2>&1"
	log_must eval "zfs get projectquota@$prj $snap_fs >/dev/null 2>&1"
	log_must eval "zfs get projectobjquota@$prj $QFS >/dev/null 2>&1"
	log_must eval "zfs get projectobjquota@$prj $snap_fs >/dev/null 2>&1"
	done

	log_pass "Check the invalid parameter of zfs get project{obj}quota"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/projectquota/projectquota_008_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/projectquota/projectquota_008_pos.ksh
	index 365b5627e801..b045b2c5fce3 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/projectquota/projectquota_008_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/projectquota/projectquota_008_pos.ksh
	@@ -1,91 +1,89 @@
	#!/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) 2017 by Fan Yong. All rights reserved.
	#

	. $STF_SUITE/tests/functional/projectquota/projectquota_common.kshlib

	#
	# DESCRIPTION:
	# Check project{obj}quota to snapshot that:
	# 1) can not set project{obj}quota to snapshot directly
	# 2) snapshot can inherit the parent fs's project{obj}quota
	# 3) the project{obj}quota will not change even the parent quota changed.
	#
	#
	# STRATEGY:
	# 1. create a snapshot of a fs
	# 2. set the project{obj}quota to snapshot and expect fail
	# 3. set project{obj}quota to fs and check the snapshot
	# 4. re-set project{obj}quota to fs and check the snapshot's value
	#

	function cleanup
	{
	- if datasetexists $snap_fs; then
	- log_must zfs destroy $snap_fs
	- fi
	+ datasetexists $snap_fs && destroy_dataset $snap_fs

	log_must cleanup_projectquota
	}

	log_onexit cleanup

	log_assert "Check the snapshot's project{obj}quota"
	typeset snap_fs=$QFS@snap


	log_must zfs set projectquota@$PRJID1=$PQUOTA_LIMIT $QFS
	log_must check_quota "projectquota@$PRJID1" $QFS "$PQUOTA_LIMIT"

	log_must zfs set projectobjquota@$PRJID2=$PQUOTA_OBJLIMIT $QFS
	log_must check_quota "projectobjquota@$PRJID2" $QFS "$PQUOTA_OBJLIMIT"

	log_must zfs snapshot $snap_fs

	log_note "check the snapshot $snap_fs project{obj}quota"
	log_must check_quota "projectquota@$PRJID1" $snap_fs "$PQUOTA_LIMIT"
	log_must check_quota "projectobjquota@$PRJID2" $snap_fs "$PQUOTA_OBJLIMIT"

	log_note "set project{obj}quota to $snap_fs which will fail"
	log_mustnot zfs set projectquota@$PRJID1=100m $snap_fs
	log_mustnot zfs set projectobjquota@$PRJID2=100 $snap_fs

	log_note "change the parent's project{obj}quota"
	log_must zfs set projectquota@$PRJID1=$((PQUOTA_LIMIT * 2)) $QFS
	log_must zfs set projectobjquota@$PRJID2=50 $QFS

	log_must check_quota "projectquota@$PRJID1" $QFS $((PQUOTA_LIMIT * 2))
	log_must check_quota "projectobjquota@$PRJID2" $QFS 50

	log_note "check the snapshot $snap_fs project{obj}quota"
	log_must check_quota "projectquota@$PRJID1" $snap_fs "$PQUOTA_LIMIT"
	log_must check_quota "projectobjquota@$PRJID2" $snap_fs "$PQUOTA_OBJLIMIT"

	log_pass "Check the snapshot's project{obj}quota"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/projectquota/projectquota_009_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/projectquota/projectquota_009_pos.ksh
	index a867b538c120..da44e731a92d 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/projectquota/projectquota_009_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/projectquota/projectquota_009_pos.ksh
	@@ -1,131 +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 2009 Sun Microsystems, Inc. All rights reserved.
	# Use is subject to license terms.
	#

	#
	# Copyright (c) 2017 by Fan Yong. All rights reserved.
	#

	. $STF_SUITE/tests/functional/projectquota/projectquota_common.kshlib

	#
	# DESCRIPTION:
	# The project{obj}quota will not change during zfs actions, such as
	# snapshot,clone,rename,upgrade,send,receive.
	#
	#
	# STRATEGY:
	# 1. Create a pool, and create fs with preset project{obj}quota
	# 2. Check set project{obj}quota via zfs snapshot\|clone\|list -o
	# 3. Check the project{obj}quota can not change during zfs
	# rename\|upgrade\|promote
	# 4. Check the project{obj}quota can not change during zfs clone
	# 5. Check the project{obj}quota can not change during zfs send/receive
	#

	function cleanup
	{
	for ds in $TESTPOOL/fs $TESTPOOL/fs-rename $TESTPOOL/fs-clone; do
	- if datasetexists $ds; then
	- log_must zfs destroy -rRf $ds
	- fi
	+ datasetexists $ds && destroy_dataset $ds -rRf
	done
	}

	log_onexit cleanup

	log_assert "the project{obj}quota can't change during zfs actions"

	cleanup

	log_must zfs create -o projectquota@$PRJID1=$PQUOTA_LIMIT \
	-o projectobjquota@$PRJID2=$PQUOTA_OBJLIMIT $TESTPOOL/fs

	log_must zfs snapshot $TESTPOOL/fs@snap
	log_must eval "zfs list -r -o projectquota@$PRJID1,projectobjquota@$PRJID2 \
	$TESTPOOL >/dev/null 2>&1"

	log_must check_quota "projectquota@$PRJID1" $TESTPOOL/fs@snap "$PQUOTA_LIMIT"
	log_must check_quota "projectobjquota@$PRJID2" $TESTPOOL/fs@snap \
	"$PQUOTA_OBJLIMIT"


	log_note "clone fs gets its parent's project{obj}quota initially"
	log_must zfs clone -o projectquota@$PRJID1=$PQUOTA_LIMIT \
	-o projectobjquota@$PRJID2=$PQUOTA_OBJLIMIT \
	$TESTPOOL/fs@snap $TESTPOOL/fs-clone

	log_must eval "zfs list -r -o projectquota@$PRJID1,projectobjquota@$PRJID2 \
	$TESTPOOL >/dev/null 2>&1"

	log_must check_quota "projectquota@$PRJID1" $TESTPOOL/fs-clone "$PQUOTA_LIMIT"
	log_must check_quota "projectobjquota@$PRJID2" $TESTPOOL/fs-clone \
	"$PQUOTA_OBJLIMIT"

	log_must eval "zfs list -o projectquota@$PRJID1,projectobjquota@$PRJID2 \
	$TESTPOOL/fs-clone >/dev/null 2>&1"

	log_note "zfs promote can not change the previously set project{obj}quota"
	log_must zfs promote $TESTPOOL/fs-clone

	log_must eval "zfs list -r -o projectquota@$PRJID1,projectobjquota@$PRJID2 \
	$TESTPOOL >/dev/null 2>&1"

	log_must check_quota "projectquota@$PRJID1" $TESTPOOL/fs-clone "$PQUOTA_LIMIT"
	log_must check_quota "projectobjquota@$PRJID2" $TESTPOOL/fs-clone \
	"$PQUOTA_OBJLIMIT"

	log_note "zfs send receive can not change the previously set project{obj}quota"
	log_must zfs send $TESTPOOL/fs-clone@snap \| zfs receive $TESTPOOL/fs-rev

	log_must eval "zfs list -r -o projectquota@$PRJID1,projectobjquota@$PRJID2 \
	$TESTPOOL >/dev/null 2>&1"

	log_must check_quota "projectquota@$PRJID1" $TESTPOOL/fs-rev "$PQUOTA_LIMIT"
	log_must check_quota "projectobjquota@$PRJID2" $TESTPOOL/fs-rev \
	"$PQUOTA_OBJLIMIT"

	log_note "zfs rename can not change the previously set project{obj}quota"
	log_must zfs rename $TESTPOOL/fs-rev $TESTPOOL/fs-rename

	log_must eval "zfs list -r -o projectquota@$PRJID1,projectobjquota@$PRJID2 \
	$TESTPOOL >/dev/null 2>&1"

	log_must check_quota "projectquota@$PRJID1" $TESTPOOL/fs-rename "$PQUOTA_LIMIT"
	log_must check_quota "projectobjquota@$PRJID2" $TESTPOOL/fs-rename \
	"$PQUOTA_OBJLIMIT"

	log_note "zfs upgrade can not change the previously set project{obj}quota"
	log_must zfs upgrade $TESTPOOL/fs-rename

	log_must eval "zfs list -r -o projectquota@$PRJID1,projectobjquota@$PRJID2 \
	$TESTPOOL >/dev/null 2>&1"

	log_must check_quota "projectquota@$PRJID1" $TESTPOOL/fs-rename "$PQUOTA_LIMIT"
	log_must check_quota "projectobjquota@$PRJID2" $TESTPOOL/fs-rename \
	"$PQUOTA_OBJLIMIT"

	log_pass "the project{obj}quota can't change during zfs actions"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/projectquota/projectspace_001_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/projectquota/projectspace_001_pos.ksh
	index a84ff9f89a0d..b7707ea522c4 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/projectquota/projectspace_001_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/projectquota/projectspace_001_pos.ksh
	@@ -1,93 +1,91 @@
	#!/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) 2017 by Fan Yong. Fan rights reserved.
	#

	. $STF_SUITE/tests/functional/projectquota/projectquota_common.kshlib

	#
	# DESCRIPTION:
	# Check the zfs projectspace with kinds of parameters
	#
	#
	# STRATEGY:
	# 1. set zfs projectspace to a fs
	# 2. write some data to the fs with specified project ID
	# 3. use zfs projectspace with all possible parameters to check the result
	# 4. use zfs projectspace with some bad parameters to check the result
	#

	function cleanup
	{
	- if datasetexists $snap_fs; then
	- log_must zfs destroy $snap_fs
	- fi
	+ datasetexists $snap_fs && destroy_dataset $snap_fs

	log_must cleanup_projectquota
	}

	if ! lsattr -pd > /dev/null 2>&1; then
	log_unsupported "Current e2fsprogs does not support set/show project ID"
	fi

	log_onexit cleanup

	log_assert "Check the zfs projectspace with all possible parameters"

	set -A good_params -- "-H" "-p" "-o type,name,used,quota" "-o name,used,quota" \
	"-o used,quota" "-o objused" "-o quota" "-s type" "-s name" "-s used" \
	"-s quota" "-S type" "-S name" "-S used" "-S quota"

	typeset snap_fs=$QFS@snap

	log_must zfs set projectquota@$PRJID1=100m $QFS
	log_must zfs set projectobjquota@$PRJID1=100 $QFS
	mkmount_writable $QFS
	log_must user_run $PUSER mkdir $PRJDIR
	log_must chattr +P -p $PRJID1 $PRJDIR
	log_must user_run $PUSER mkfile 50m $PRJDIR/qf
	sync

	log_must zfs snapshot $snap_fs

	for param in "${good_params[@]}"; do
	log_must eval "zfs projectspace $param $QFS >/dev/null 2>&1"
	log_must eval "zfs projectspace $param $snap_fs >/dev/null 2>&1"
	done

	log_assert "Check the zfs projectspace with some bad parameters"

	set -A bad_params -- "-i" "-n" "-P" "-t posixuser"

	for param in "${bad_params[@]}"; do
	log_mustnot eval "zfs projectspace $param $QFS >/dev/null 2>&1"
	log_mustnot eval "zfs projectspace $param $snap_fs >/dev/null 2>&1"
	done

	log_pass "zfs projectspace with kinds of parameters pass"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/projectquota/projectspace_002_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/projectquota/projectspace_002_pos.ksh
	index 216855e94dc9..10edae771e99 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/projectquota/projectspace_002_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/projectquota/projectspace_002_pos.ksh
	@@ -1,85 +1,83 @@
	#!/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) 2017 by Fan Yong. All rights reserved.
	#

	. $STF_SUITE/tests/functional/projectquota/projectquota_common.kshlib

	#
	# DESCRIPTION:
	# Check the project used size and quota in zfs projectspace
	#
	#
	# STRATEGY:
	# 1. set zfs projectquota to a fs
	# 2. write some data to the fs with specified project and size
	# 3. use zfs projectspace to check the used size and quota size
	#

	function cleanup
	{
	- if datasetexists $snapfs; then
	- log_must zfs destroy $snapfs
	- fi
	+ datasetexists $snapfs && destroy_dataset $snapfs

	log_must cleanup_projectquota
	}

	if ! lsattr -pd > /dev/null 2>&1; then
	log_unsupported "Current e2fsprogs does not support set/show project ID"
	fi

	log_onexit cleanup

	log_assert "Check the zfs projectspace used and quota"

	log_must zfs set projectquota@$PRJID1=100m $QFS

	mkmount_writable $QFS
	log_must user_run $PUSER mkdir $PRJDIR
	log_must chattr +P -p $PRJID1 $PRJDIR
	log_must user_run $PUSER mkfile 50m $PRJDIR/qf
	sync

	typeset snapfs=$QFS@snap

	log_must zfs snapshot $snapfs

	log_must eval "zfs projectspace $QFS >/dev/null 2>&1"
	log_must eval "zfs projectspace $snapfs >/dev/null 2>&1"

	for fs in "$QFS" "$snapfs"; do
	log_note "check the quota size in zfs projectspace $fs"
	log_must eval "zfs projectspace $fs \| grep $PRJID1 \| grep 100M"

	log_note "check the project used size in zfs projectspace $fs"
	log_must eval "zfs projectspace $fs \| grep $PRJID1 \| grep 50\\.\*M"
	done

	log_pass "Check the zfs projectspace used and quota"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/projectquota/projectspace_003_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/projectquota/projectspace_003_pos.ksh
	index 629b3b3e57e2..8db5d0d89970 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/projectquota/projectspace_003_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/projectquota/projectspace_003_pos.ksh
	@@ -1,118 +1,116 @@
	#!/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) 2017 by Fan Yong. All rights reserved.
	#

	. $STF_SUITE/tests/functional/projectquota/projectquota_common.kshlib

	#
	# DESCRIPTION:
	# Check the project used object accounting in zfs projectspace
	#
	#
	# STRATEGY:
	# 1. create a bunch of files by specific project
	# 2. use zfs projectspace to check the used objects
	# 3. change the project ID of test files and verify object count
	# 4. delete files and verify object count
	#

	function cleanup
	{
	- if datasetexists $snapfs; then
	- log_must zfs destroy $snapfs
	- fi
	+ datasetexists $snapfs && destroy_dataset $snapfs

	log_must cleanup_projectquota
	}

	if ! lsattr -pd > /dev/null 2>&1; then
	log_unsupported "Current e2fsprogs does not support set/show project ID"
	fi

	log_onexit cleanup

	log_assert "Check the zfs projectspace object used"

	mkmount_writable $QFS
	log_must zfs set xattr=sa $QFS
	log_must user_run $PUSER mkdir $PRJDIR1
	log_must user_run $PUSER mkdir $PRJDIR2
	log_must chattr +P -p $PRJID1 $PRJDIR1
	log_must chattr +P -p $PRJID2 $PRJDIR2

	((prj_cnt1 = RANDOM % 100 + 2))
	((prj_cnt2 = RANDOM % 100 + 2))

	log_must user_run $PUSER mkfiles $PRJDIR1/qf $((prj_cnt1 - 1))
	log_must user_run $PUSER mkfiles $PRJDIR2/qf $((prj_cnt2 - 1))
	sync_pool

	typeset snapfs=$QFS@snap

	log_must zfs snapshot $snapfs

	log_must eval "zfs projectspace $QFS >/dev/null 2>&1"
	log_must eval "zfs projectspace $snapfs >/dev/null 2>&1"

	for fs in "$QFS" "$snapfs"; do
	log_note "check the project used objects in zfs projectspace $fs"
	prjused=$(project_obj_count $fs $PRJID1)
	[[ $prjused -eq $prj_cnt1 ]] \|\|
	log_fail "($PRJID1) expected $prj_cnt1, got $prjused"
	prjused=$(project_obj_count $fs $PRJID2)
	[[ $prjused -eq $prj_cnt2 ]] \|\|
	log_fail "($PRJID2) expected $prj_cnt2, got $prjused"
	done

	log_note "change the project of files"
	log_must chattr -p $PRJID2 $PRJDIR1/qf*
	sync_pool

	prjused=$(project_obj_count $QFS $PRJID1)
	[[ $prjused -eq 1 ]] \|\|
	log_fail "expected 1 for project $PRJID1, got $prjused"

	prjused=$(project_obj_count $snapfs $PRJID1)
	[[ $prjused -eq $prj_cnt1 ]] \|\|
	log_fail "expected $prj_cnt1 for $PRJID1 in snapfs, got $prjused"

	prjused=$(project_obj_count $QFS $PRJID2)
	[[ $prjused -eq $((prj_cnt1 + prj_cnt2 - 1)) ]] \|\|
	log_fail "($PRJID2) expected $((prj_cnt1 + prj_cnt2 - 1)), got $prjused"

	log_note "file removal"
	log_must rm -rf $PRJDIR1
	sync_pool

	prjused=$(project_obj_count $QFS $PRJID1)
	[[ $prjused -eq 0 ]] \|\| log_fail "expected 0 for $PRJID1, got $prjused"

	cleanup
	log_pass "Check the zfs projectspace object used"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/projectquota/projectspace_004_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/projectquota/projectspace_004_pos.ksh
	index ec299e0e7f93..fc4a93f04463 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/projectquota/projectspace_004_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/projectquota/projectspace_004_pos.ksh
	@@ -1,76 +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 2009 Sun Microsystems, Inc. All rights reserved.
	# Use is subject to license terms.
	#

	#
	# Copyright (c) 2017 by Fan Yong. Fan rights reserved.
	#

	. $STF_SUITE/tests/functional/projectquota/projectquota_common.kshlib

	#
	# DESCRIPTION:
	# Check 'df' command on the directory with INHERIT (project ID) flag
	#
	#
	# STRATEGY:
	# 1. set project [obj]quota on the directory
	# 2. set project ID and inherit flag on the directory
	# 3. run 'df [-i]' on the directory and check the result
	#

	function cleanup
	{
	- if datasetexists $snap_fs; then
	- log_must zfs destroy $snap_fs
	- fi
	+ datasetexists $snap_fs && destroy_dataset $snap_fs

	log_must cleanup_projectquota
	}

	if ! lsattr -pd > /dev/null 2>&1; then
	log_unsupported "Current e2fsprogs does not support set/show project ID"
	fi

	log_onexit cleanup

	log_assert "Check 'df' on dir with inherit project shows the project quota/used"

	log_must zfs set projectquota@$PRJID1=100m $QFS
	log_must zfs set projectobjquota@$PRJID1=100 $QFS
	mkmount_writable $QFS
	log_must user_run $PUSER mkdir $PRJDIR
	log_must chattr +P -p $PRJID1 $PRJDIR
	log_must user_run $PUSER mkfile 50m $PRJDIR/qf
	sync_pool

	total=$(df $PRJDIR \| tail -n 1 \| awk '{ print $2 }')
	[[ $total -eq 102400 ]] \|\| log_fail "expect '102400' resource, but got '$total'"

	used=$(df -i $PRJDIR \| tail -n 1 \| awk '{ print $5 }')
	[[ "$used" == "2%" ]] \|\| log_fail "expect '2%' used, but got '$used'"

	log_pass "'df' on the directory with inherit project ID flag pass as expect"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/quota/quota_005_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/quota/quota_005_pos.ksh
	index ed28cc1f0c9b..e87139a58f69 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/quota/quota_005_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/quota/quota_005_pos.ksh
	@@ -1,76 +1,75 @@
	#! /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/quota/quota.kshlib

	#
	# DESCRIPTION:
	#
	# Verify that quota doesn't inherit its value from parent.
	#
	# STRATEGY:
	# 1) Set quota for parents
	# 2) Create a filesystem tree
	# 3) Verify that the 'quota' for descendent doesnot inherit the value.
	#
	###############################################################################

	verify_runnable "both"

	function cleanup
	{
	- datasetexists $fs_child && \
	- log_must zfs destroy $fs_child
	+ datasetexists $fs_child && destroy_dataset $fs_child

	log_must zfs set quota=$quota_val $fs
	}

	log_onexit cleanup

	log_assert "Verify that quota doesnot inherit its value from parent."
	log_onexit cleanup

	fs=$TESTPOOL/$TESTFS
	fs_child=$TESTPOOL/$TESTFS/$TESTFS

	space_avail=$(get_prop available $fs)
	quota_val=$(get_prop quota $fs)
	typeset -i quotasize=$space_avail
	((quotasize = quotasize * 2 ))
	log_must zfs set quota=$quotasize $fs

	log_must zfs create $fs_child
	quota_space=$(get_prop quota $fs_child)
	[[ $quota_space == $quotasize ]] && \
	log_fail "The quota of child dataset inherits its value from parent."

	log_pass "quota doesnot inherit its value from parent as expected."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/refreserv/refreserv_002_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/refreserv/refreserv_002_pos.ksh
	index d4c0a4faebdc..a8f58631f7b6 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/refreserv/refreserv_002_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/refreserv/refreserv_002_pos.ksh
	@@ -1,114 +1,112 @@
	#!/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/refreserv/refreserv.cfg

	#
	# DESCRIPTION:
	# Setting full size as refreservation, verify no snapshot can be created.
	#
	# STRATEGY:
	# 1. Setting full size as refreservation on pool
	# 2. Verify no snapshot can be created on this pool
	# 3. Setting full size as refreservation on filesystem
	# 4. Verify no snapshot can be created on it and its subfs
	#

	verify_runnable "both"

	function cleanup
	{
	if is_global_zone ; then
	log_must zfs set refreservation=none $TESTPOOL

	- if datasetexists $TESTPOOL@snap ; then
	- log_must zfs destroy -f $TESTPOOL@snap
	- fi
	+ datasetexists $TESTPOOL@snap && destroy_dataset $TESTPOOL@snap -f
	fi
	- log_must zfs destroy -rf $TESTPOOL/$TESTFS
	+ destroy_dataset $TESTPOOL/$TESTFS -rf
	log_must zfs create $TESTPOOL/$TESTFS
	log_must zfs set mountpoint=$TESTDIR $TESTPOOL/$TESTFS
	}

	# This function iteratively increases refreserv to its highest possible
	# value. Simply setting refreserv == quota can allow enough writes to
	# complete that the test fails.
	function max_refreserv
	{
	typeset ds=$1
	typeset -i incsize=131072
	typeset -i rr=$(get_prop available $ds)

	log_must zfs set refreserv=$rr $ds
	while :; do
	zfs set refreserv=$((rr + incsize)) $ds >/dev/null 2>&1
	if [[ $? == 0 ]]; then
	((rr += incsize))
	continue
	else
	((incsize /= 2))
	((incsize == 0)) && break
	fi
	done
	}


	log_assert "Setting full size as refreservation, verify no snapshot " \
	"can be created."
	log_onexit cleanup

	log_must zfs create $TESTPOOL/$TESTFS/subfs

	typeset datasets
	if is_global_zone; then
	datasets="$TESTPOOL $TESTPOOL/$TESTFS $TESTPOOL/$TESTFS/subfs"
	else
	datasets="$TESTPOOL/$TESTFS $TESTPOOL/$TESTFS/subfs"
	fi

	for ds in $datasets; do
	#
	# Verify refreservation on dataset
	#
	log_must zfs set quota=25M $ds
	max_refreserv $ds
	log_mustnot zfs snapshot $ds@snap
	if datasetexists $ds@snap ; then
	log_fail "ERROR: $ds@snap should not exists."
	fi

	log_must zfs set quota=none $ds
	log_must zfs set refreservation=none $ds
	done

	log_pass "Setting full size as refreservation, verify no snapshot " \
	"can be created."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/reservation/reservation_002_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/reservation/reservation_002_pos.ksh
	index 8ae3593613f0..e0fed6389c35 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/reservation/reservation_002_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/reservation/reservation_002_pos.ksh
	@@ -1,100 +1,100 @@
	#!/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/reservation/reservation.shlib

	#
	# DESCRIPTION:
	#
	# Reservation values cannot exceed the amount of space available
	# in the pool. Verify that attempting to set a reservation greater
	# than this value fails.
	#
	# STRATEGY:
	# 1) Create a filesystem, regular and sparse volume
	# 2) Get the space available in the pool
	# 3) Attempt to set a reservation greater than the available space
	# on the filesystem and verify it fails.
	# 4) Verify that the reservation is still set to 'none' (or 0) on
	# the filesystem.
	# 5) Repeat 3-4 for regular and sparse volume
	#

	verify_runnable "both"

	function cleanup
	{
	for obj in $OBJ_LIST; do
	- datasetexists $obj && log_must_busy zfs destroy -f $obj
	+ datasetexists $obj && destroy_dataset $obj -f
	done

	log_must zero_reservation $TESTPOOL/$TESTFS
	}

	log_onexit cleanup

	log_assert "Reservation values cannot exceed the amount of space" \
	" available in the pool"

	space_avail=`get_prop available $TESTPOOL`

	if ! is_global_zone ; then
	OBJ_LIST=""
	else
	OBJ_LIST="$TESTPOOL/$TESTVOL $TESTPOOL/$TESTVOL2"

	((vol_set_size = space_avail / 4))
	vol_set_size=$(floor_volsize $vol_set_size)
	((sparse_vol_set_size = space_avail * 4))
	sparse_vol_set_size=$(floor_volsize $sparse_vol_set_size)

	log_must zfs create -V $vol_set_size $TESTPOOL/$TESTVOL
	log_must zfs set reservation=none $TESTPOOL/$TESTVOL
	log_must zfs create -s -V $sparse_vol_set_size $TESTPOOL/$TESTVOL2
	fi

	for obj in $TESTPOOL/$TESTFS $OBJ_LIST ; do

	space_avail=`get_prop available $obj`
	resv_size_set=`expr $space_avail + $RESV_DELTA`

	log_must zero_reservation $obj
	log_mustnot zfs set reservation=$resv_size_set $obj

	resv_size_get=`get_prop reservation $obj`

	if (($resv_size_get != 0)); then
	log_fail "Reservation value non-zero ($resv_size_get)"
	fi
	done

	log_pass "Attempting to set too large reservation failed as expected"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/reservation/reservation_003_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/reservation/reservation_003_pos.ksh
	index 48adabe72ffd..ee303b53bedd 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/reservation/reservation_003_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/reservation/reservation_003_pos.ksh
	@@ -1,134 +1,134 @@
	#!/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:
	#
	# Verify that it's possible to set a reservation on a filesystem,
	# or volume multiple times, without resetting the reservation
	# to none.
	#
	# STRATEGY:
	# 1) Create a regular volume and a sparse volume
	# 2) Get the space available in the pool
	# 3) Set a reservation on the filesystem less than the space available.
	# 4) Verify that the 'reservation' property for the filesystem has
	# the correct value.
	# 5) Repeat 2-4 for different reservation values
	# 6) Repeat 3-5 for regular and sparse volume
	#

	verify_runnable "both"

	log_assert "Verify it is possible to set reservations multiple times " \
	"on a filesystem regular and sparse volume"

	function cleanup
	{
	log_must zero_reservation $TESTPOOL/$TESTFS

	for obj in $OBJ_LIST; do
	- datasetexists $obj && log_must zfs destroy -f $obj
	+ datasetexists $obj && destroy_dataset $obj -f
	done
	}

	log_onexit cleanup


	#
	# Set a reservation $RESV_ITER times on a dataset and verify that
	# the reservation is correctly set each time.
	#
	function multiple_resv { #dataset
	typeset -i i=0

	dataset=$1

	log_must zero_reservation $dataset
	space_avail=`get_prop available $TESTPOOL`

	((resv_size = (space_avail - RESV_DELTA) / RESV_ITER))

	#
	# For regular (non-sparse) volumes the upper limit is determined
	# not by the space available in the pool but rather by the size
	# of the volume itself.
	#
	[[ $obj == $TESTPOOL/$TESTVOL ]] && \
	((resv_size = (vol_set_size - RESV_DELTA) / RESV_ITER))

	resv_size_set=$resv_size

	while (($i < $RESV_ITER)); do

	((i = i + 1))

	((resv_size_set = resv_size * i))

	log_must zfs set reservation=$resv_size_set $dataset

	resv_size_get=`get_prop reservation $dataset`
	if [[ $resv_size_set != $resv_size_get ]]; then
	log_fail "Reservation not the expected value " \
	"($resv_size_set != $resv_size_get)"
	fi
	done

	log_must zero_reservation $dataset
	}

	space_avail=`get_prop available $TESTPOOL`

	if ! is_global_zone ; then
	OBJ_LIST=""
	else
	OBJ_LIST="$TESTPOOL/$TESTVOL $TESTPOOL/$TESTVOL2"

	((vol_set_size = space_avail / 4))
	vol_set_size=$(floor_volsize $vol_set_size)
	((sparse_vol_set_size = space_avail * 4))
	sparse_vol_set_size=$(floor_volsize $sparse_vol_set_size)


	log_must zfs create -V $vol_set_size $TESTPOOL/$TESTVOL
	log_must zfs set reservation=none $TESTPOOL/$TESTVOL
	log_must zfs create -s -V $sparse_vol_set_size $TESTPOOL/$TESTVOL2
	fi

	for obj in $TESTPOOL/$TESTFS $OBJ_LIST ; do
	multiple_resv $obj
	done

	log_pass "Multiple reservations successfully set on filesystem" \
	" and both volume types"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/reservation/reservation_004_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/reservation/reservation_004_pos.ksh
	index f8342ff29488..eb606a762432 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/reservation/reservation_004_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/reservation/reservation_004_pos.ksh
	@@ -1,130 +1,130 @@
	#!/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
	. $STF_SUITE/tests/functional/reservation/reservation.shlib

	#
	# DESCRIPTION:
	#
	# When a dataset which has a reservation set on it is destroyed,
	# the space consumed or reserved by that dataset should be released
	# back into the pool.
	#
	# STRATEGY:
	# 1) Create a filesystem, regular and sparse volume
	# 2) Get the space used and available in the pool
	# 3) Set a reservation on the filesystem less than the space available.
	# 4) Verify that the 'reservation' property for the filesystem has
	# the correct value.
	# 5) Destroy the filesystem without resetting the reservation value.
	# 6) Verify that the space used and available totals for the pool have
	# changed by the expected amounts (within tolerances).
	# 7) Repeat steps 3-6 for a regular volume and sparse volume
	#

	verify_runnable "both"

	function cleanup {

	for obj in $OBJ_LIST; do
	- datasetexists $obj && log_must_busy zfs destroy -f $obj
	+ datasetexists $obj && destroy_dataset $obj -f
	done
	}

	log_assert "Verify space released when a dataset with reservation is destroyed"

	log_onexit cleanup

	log_must zfs create $TESTPOOL/$TESTFS2

	space_avail=`get_prop available $TESTPOOL`

	if ! is_global_zone ; then
	OBJ_LIST="$TESTPOOL/$TESTFS2"
	else
	OBJ_LIST="$TESTPOOL/$TESTFS2 \
	$TESTPOOL/$TESTVOL $TESTPOOL/$TESTVOL2"

	((vol_set_size = space_avail / 4))
	vol_set_size=$(floor_volsize $vol_set_size)
	((sparse_vol_set_size = space_avail * 4))
	sparse_vol_set_size=$(floor_volsize $sparse_vol_set_size)

	log_must zfs create -V $vol_set_size $TESTPOOL/$TESTVOL
	log_must zfs set refreservation=none $TESTPOOL/$TESTVOL
	log_must zfs set reservation=none $TESTPOOL/$TESTVOL
	log_must zfs create -s -V $sparse_vol_set_size $TESTPOOL/$TESTVOL2
	fi

	# re-calculate space available.
	space_avail=`get_prop available $TESTPOOL`

	# Calculate a large but valid reservation value.
	resv_size_set=`expr $space_avail - $RESV_DELTA`

	for obj in $OBJ_LIST ; do

	space_avail=`get_prop available $TESTPOOL`
	space_used=`get_prop used $TESTPOOL`

	#
	# For regular (non-sparse) volumes the upper limit is determined
	# not by the space available in the pool but rather by the size
	# of the volume itself.
	#
	[[ $obj == $TESTPOOL/$TESTVOL ]] && \
	((resv_size_set = vol_set_size - RESV_DELTA))

	log_must zfs set reservation=$resv_size_set $obj

	resv_size_get=`get_prop reservation $obj`
	if [[ $resv_size_set != $resv_size_get ]]; then
	log_fail "Reservation not the expected value " \
	"($resv_size_set != $resv_size_get)"
	fi

	log_must_busy zfs destroy -f $obj

	new_space_avail=`get_prop available $TESTPOOL`
	new_space_used=`get_prop used $TESTPOOL`

	#
	# Recent changes to metaslab logic have caused these tests to expand
	# outside of their previous tolerance. If this is discovered to be a
	# bug, rather than a side effect of some interactions, the reservation
	# should be halved again.
	#
	log_must within_limits $space_used $new_space_used $RESV_TOLERANCE
	log_must within_limits $space_avail $new_space_avail $RESV_TOLERANCE
	done

	log_pass "Space correctly released when dataset is destroyed"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/reservation/reservation_005_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/reservation/reservation_005_pos.ksh
	index 4047fab0d7f9..535d652dafab 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/reservation/reservation_005_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/reservation/reservation_005_pos.ksh
	@@ -1,118 +1,118 @@
	#!/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/reservation/reservation.shlib

	#
	# DESCRIPTION:
	#
	# When a reservation property of a filesystem, regular volume
	# or sparse volume is set to 'none' the space previously consumed by the
	# reservation should be released back to the pool
	#
	# STRATEGY:
	# 1) Create a filesystem, regular volume and sparse volume
	# 2) Get the space used and available in the pool
	# 3) Set a reservation on the filesystem less than the space available.
	# 4) Verify that the 'reservation' property for the filesystem has
	# the correct value.
	# 5) Reset the reservation value back to zero (or 'none')
	# 6) Verify that the space used and available totals for the pool have
	# changed by the expected amounts (within tolerances).
	# 7) Repeat steps 3-6 for a regular volume, sparse volume
	#

	verify_runnable "both"

	log_assert "Verify space released when reservation on a dataset is set "\
	"to 'none'"

	function cleanup
	{
	for obj in $OBJ_LIST; do
	- datasetexists $obj && log_must zfs destroy -f $obj
	+ datasetexists $obj && destroy_dataset $obj -f
	done
	}

	log_onexit cleanup

	space_avail=`get_prop available $TESTPOOL`

	if ! is_global_zone ; then
	OBJ_LIST=""
	else
	OBJ_LIST="$TESTPOOL/$TESTVOL $TESTPOOL/$TESTVOL2"
	((vol_set_size = space_avail / 4))
	vol_set_size=$(floor_volsize $vol_set_size)
	((sparse_vol_set_size = space_avail * 4))
	sparse_vol_set_size=$(floor_volsize $sparse_vol_set_size)


	log_must zfs create -V $vol_set_size $TESTPOOL/$TESTVOL
	log_must zfs set reservation=none $TESTPOOL/$TESTVOL
	log_must zfs create -s -V $sparse_vol_set_size $TESTPOOL/$TESTVOL2
	fi

	space_avail=`get_prop available $TESTPOOL`
	space_used=`get_prop used $TESTPOOL`

	# Calculate a large but valid reservation value.
	resv_size_set=`expr $space_avail - $RESV_DELTA`

	for obj in $TESTPOOL/$TESTFS $OBJ_LIST ; do

	#
	# For regular (non-sparse) volumes the upper limit is determined
	# not by the space available in the pool but rather by the size
	# of the volume itself.
	#
	[[ $obj == $TESTPOOL/$TESTVOL ]] && \
	((resv_size_set = vol_set_size - RESV_DELTA))

	log_must zfs set reservation=$resv_size_set $obj

	resv_size_get=`get_prop reservation $obj`
	if [[ $resv_size_set != $resv_size_get ]]; then
	log_fail "Reservation not the expected value "\
	"($resv_size_set != $resv_size_get)"
	fi

	log_must zfs set reservation=none $obj

	new_space_avail=`get_prop available $TESTPOOL`
	new_space_used=`get_prop used $TESTPOOL`

	log_must within_limits $space_used $new_space_used $RESV_TOLERANCE
	log_must within_limits $space_avail $new_space_avail $RESV_TOLERANCE
	done

	log_pass "Space correctly released when dataset reservation set to 'none'"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/reservation/reservation_007_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/reservation/reservation_007_pos.ksh
	index 48d6b40ad05a..a1fffd362427 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/reservation/reservation_007_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/reservation/reservation_007_pos.ksh
	@@ -1,128 +1,128 @@
	#!/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/reservation/reservation.shlib

	#
	# DESCRIPTION:
	#
	# Setting a reservation on dataset should have no effect on any other
	# dataset at the same level in the hierarchy beyond using up available
	# space in the pool.
	#
	# STRATEGY:
	# 1) Create a filesystem
	# 2) Set a reservation on the filesystem
	# 3) Create another filesystem at the same level
	# 4) Set a reservation on the second filesystem
	# 5) Destroy both the filesystems
	# 6) Verify space accounted for correctly
	#

	verify_runnable "both"

	log_assert "Verify reservations on data sets doesn't affect other data sets " \
	"at same level except for consuming space from common pool"

	function cleanup
	{
	datasetexists $TESTPOOL/$TESTFS2 && \
	- log_must zfs destroy -f $TESTPOOL/$TESTFS2
	+ destroy_dataset $TESTPOOL/$TESTFS2 -f

	datasetexists $TESTPOOL/$TESTFS1 && \
	- log_must zfs destroy -f $TESTPOOL/$TESTFS1
	+ destroy_dataset $TESTPOOL/$TESTFS1 -f
	}

	log_onexit cleanup

	space_avail=`get_prop available $TESTPOOL`
	space_used=`get_prop used $TESTPOOL`

	resv_size_set=`expr $space_avail / 3`

	#
	# Function which creates two datasets, sets reservations on them,
	# then destroys them and ensures that space is correctly accounted
	# for.
	#
	# Any special arguments for create are passed in via the args
	# parameter.
	#
	function create_resv_destroy { # args1 dataset1 args2 dataset2

	args1=$1
	dataset1=$2
	args2=$3
	dataset2=$4

	log_must zfs create $args1 $dataset1

	log_must zfs set reservation=$RESV_SIZE $dataset1

	avail_aft_dset1=`get_prop available $TESTPOOL`
	used_aft_dset1=`get_prop used $TESTPOOL`

	log_must zfs create $args2 $dataset2

	log_must zfs set reservation=$RESV_SIZE $dataset2

	#
	# After destroying the second dataset the space used and
	# available totals should revert back to the values they
	# had after creating the first dataset.
	#
	- log_must zfs destroy -f $dataset2
	+ log_must_busy zfs destroy -f $dataset2

	avail_dest_dset2=`get_prop available $TESTPOOL`
	used_dest_dset2=`get_prop used $TESTPOOL`

	log_must within_limits $avail_aft_dset1 $avail_dest_dset2 $RESV_TOLERANCE
	log_must within_limits $used_aft_dset1 $used_dest_dset2 $RESV_TOLERANCE


	# After destroying the first dataset the space used and
	# space available totals should revert back to the values
	# they had when the pool was first created.
	- log_must zfs destroy -f $dataset1
	+ log_must_busy zfs destroy -f $dataset1

	avail_dest_dset1=`get_prop available $TESTPOOL`
	used_dest_dset1=`get_prop used $TESTPOOL`

	log_must within_limits $avail_dest_dset1 $space_avail $RESV_TOLERANCE
	log_must within_limits $used_dest_dset1 $space_used $RESV_TOLERANCE
	}

	create_resv_destroy "" $TESTPOOL/$TESTFS1 "" $TESTPOOL/$TESTFS2
	create_resv_destroy "" $TESTPOOL/$TESTFS2 "" $TESTPOOL/$TESTFS1

	log_pass "Verify reservations on data sets doesn't affect other data sets at" \
	" same level except for consuming space from common pool"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/reservation/reservation_008_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/reservation/reservation_008_pos.ksh
	index a0cd039b1839..cfc30f47421b 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/reservation/reservation_008_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/reservation/reservation_008_pos.ksh
	@@ -1,124 +1,124 @@
	#!/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:
	#
	# Setting a reservation reserves a defined minimum amount of space for
	# a dataset, and prevents other datasets using that space. Verify that
	# reducing the reservation on a filesystem allows other datasets in
	# the pool to use that space.
	#
	# STRATEGY:
	# 1) Create multiple filesystems
	# 2) Set reservations on all bar one of the filesystems
	# 3) Fill up the one non-reserved filesystem
	# 4) Reduce one of the reservations and verify can write more
	# data into the non-reserved filesystem
	#

	verify_runnable "both"

	log_assert "Verify reducing reservation allows other datasets to use space"

	function cleanup
	{
	typeset -i loop=0
	while (($loop < $RESV_NUM_FS)); do
	datasetexists $TESTPOOL/${TESTFS}$loop && \
	- log_must zfs destroy -f $TESTPOOL/${TESTFS}$loop
	+ destroy_dataset $TESTPOOL/${TESTFS}$loop -f

	[[ -d ${TESTDIR}$loop ]] && log_must rm -r ${TESTDIR}$loop

	((loop = loop + 1))
	done
	}

	log_onexit cleanup

	log_must create_multiple_fs $RESV_NUM_FS $TESTPOOL/$TESTFS $TESTDIR

	space_avail=`get_prop available $TESTPOOL`
	space_used=`get_prop used $TESTPOOL`

	#
	# To make sure this test doesn't take too long to execute on
	# large pools, we calculate a reservation setting which when
	# applied to all bar one of the filesystems (RESV_NUM_FS-1) will
	# ensure we have RESV_FREE_SPACE left free in the pool, which we will
	# be able to quickly fill.
	#
	resv_space_avail=`expr $space_avail - $RESV_FREE_SPACE`
	num_resv_fs=`expr $RESV_NUM_FS - 1` # Number of FS to which resv will be applied
	resv_size_set=`expr $resv_space_avail / $num_resv_fs`

	#
	# We set the reservations now, rather than when we created the filesystems
	# to allow us to take into account space used by the filesystem metadata
	#
	# Note we don't set a reservation on the first filesystem we created,
	# hence num=1 rather than zero below.
	#
	typeset -i num=1
	while (($num < $RESV_NUM_FS)); do
	log_must zfs set reservation=$resv_size_set $TESTPOOL/$TESTFS$num
	((num = num + 1))
	done

	space_avail_still=`get_prop available $TESTPOOL`

	fill_size=`expr $space_avail_still + $RESV_TOLERANCE`
	write_count=`expr $fill_size / $BLOCK_SIZE`

	# Now fill up the first filesystem (which doesn't have a reservation set
	# and thus will use up whatever free space is left in the pool).
	num=0
	log_note "Writing to $TESTDIR$num/$TESTFILE1"

	file_write -o create -f $TESTDIR$num/$TESTFILE1 -b $BLOCK_SIZE \
	-c $write_count -d 0
	ret=$?
	if (($ret != $ENOSPC)); then
	log_fail "Did not get ENOSPC as expected (got $ret)."
	fi

	# Remove the reservation on one of the other filesystems and verify
	# can write more data to the original non-reservation filesystem.
	num=1
	log_must zfs set reservation=none $TESTPOOL/${TESTFS}$num
	num=0
	log_must file_write -o create -f ${TESTDIR}$num/$TESTFILE2 \
	-b $(getconf PAGESIZE) -c 1000 -d 0

	log_pass "reducing reservation allows other datasets to use space"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/reservation/reservation_009_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/reservation/reservation_009_pos.ksh
	index 171577def5ef..a639abf8960a 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/reservation/reservation_009_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/reservation/reservation_009_pos.ksh
	@@ -1,100 +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 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:
	#
	# In pool with a full filesystem and another filesystem with a reservation
	# setting the reservation on the second filesystem to 'none' should allow more
	# data to be written to the first filesystem.
	#
	#
	# STRATEGY:
	# 1) Create a filesystem as a dataset
	# 2) Create a filesystem at the same level
	# 3) Set a reservation on the dataset filesystem
	# 4) Fill up the filesystem
	# 5) Set the reservation on the dataset filesystem to 'none'
	# 6) Verify we can write more data to the first filesystem
	#

	verify_runnable "both"

	log_assert "Setting top level dataset reservation to 'none' allows more data " \
	"to be written to top level filesystem"

	function cleanup
	{
	log_must rm -rf $TESTDIR/$TESTFILE1
	log_must rm -rf $TESTDIR/$TESTFILE2
	- log_must zfs destroy -f $TESTPOOL/$TESTFS1
	+
	+ datasetexists $TESTPOOL/$TESTFS1 && \
	+ destroy_dataset $TESTPOOL/$TESTFS1 -f
	}

	log_onexit cleanup

	log_must zfs create $TESTPOOL/$TESTFS1

	space_avail=`get_prop available $TESTPOOL`

	#
	# To make sure this test doesn't take too long to execute on
	# large pools, we calculate a reservation setting which when
	# applied to the dataset will ensure we have RESV_FREE_SPACE
	# left free in the pool which we can quickly fill.
	#
	((resv_size_set = space_avail - RESV_FREE_SPACE))

	log_must zfs set reservation=$resv_size_set $TESTPOOL/$TESTFS1

	space_avail_still=`get_prop available $TESTPOOL`

	fill_size=`expr $space_avail_still + $RESV_TOLERANCE`
	write_count=`expr $fill_size / $BLOCK_SIZE`

	# Now fill up the filesystem (which doesn't have a reservation set
	# and thus will use up whatever free space is left in the pool).
	file_write -o create -f $TESTDIR/$TESTFILE1 -b $BLOCK_SIZE \
	-c $write_count -d 0
	ret=$?
	if (($ret != $ENOSPC)); then
	log_fail "Did not get ENOSPC as expected (got $ret)."
	fi

	log_must zfs set reservation=none $TESTPOOL/$TESTFS1

	log_must file_write -o create -f $TESTDIR/$TESTFILE2 \
	-b $(getconf PAGESIZE) -c 1000 -d 0

	log_pass "Setting top level dataset reservation to 'none' allows more " \
	"data to be written to the top level filesystem"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/reservation/reservation_010_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/reservation/reservation_010_pos.ksh
	index 2ca279a4a437..f3a64a0bea8c 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/reservation/reservation_010_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/reservation/reservation_010_pos.ksh
	@@ -1,101 +1,101 @@
	#!/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/reservation/reservation.shlib

	#
	# DESCRIPTION:
	#
	# In pool with a full filesystem and a filesystem with a reservation
	# destroying another filesystem should allow more data to be written to
	# the full filesystem
	#
	#
	# STRATEGY:
	# 1) Create a filesystem as dataset
	# 2) Create a filesystem at the same level
	# 3) Set a reservation on the dataset filesystem
	# 4) Fill up the second filesystem
	# 5) Destroy the dataset filesystem
	# 6) Verify can write more data to the full filesystem
	#

	verify_runnable "both"

	log_assert "Destroying top level filesystem with reservation allows more " \
	"data to be written to another top level filesystem"

	function cleanup
	{
	datasetexists $TESTPOOL/$TESTFS1 && \
	- log_must zfs destroy $TESTPOOL/$TESTFS1
	+ destroy_dataset $TESTPOOL/$TESTFS1

	[[ -e $TESTDIR/$TESTFILE1 ]] && log_must rm -rf $TESTDIR/$TESTFILE1
	[[ -e $TESTDIR/$TESTFILE2 ]] && log_must rm -rf $TESTDIR/$TESTFILE2
	}

	log_onexit cleanup

	log_must zfs create $TESTPOOL/$TESTFS1

	space_avail=`get_prop available $TESTPOOL`

	#
	# To make sure this test doesn't take too long to execute on
	# large pools, we calculate a reservation setting which when
	# applied to the dataset filesystem will ensure we have
	# RESV_FREE_SPACE left free in the pool.
	#
	((resv_size_set = space_avail - RESV_FREE_SPACE))

	log_must zfs set reservation=$resv_size_set $TESTPOOL/$TESTFS1

	space_avail_still=`get_prop available $TESTPOOL`

	fill_size=`expr $space_avail_still + $RESV_TOLERANCE`
	write_count=`expr $fill_size / $BLOCK_SIZE`

	# Now fill up the filesystem (which doesn't have a reservation set
	# and thus will use up whatever free space is left in the pool).
	file_write -o create -f $TESTDIR/$TESTFILE1 -b $BLOCK_SIZE -c $write_count -d 0
	ret=$?
	if (($ret != $ENOSPC)); then
	log_fail "Did not get ENOSPC as expected (got $ret)."
	fi

	log_must zfs destroy -f $TESTPOOL/$TESTFS1

	log_must file_write -o create -f $TESTDIR/$TESTFILE2 \
	-b $(getconf PAGESIZE) -c 1000 -d 0

	log_pass "Destroying top level filesystem with reservation allows more data " \
	"to be written to another top level filesystem"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/reservation/reservation_013_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/reservation/reservation_013_pos.ksh
	index 6a80bb575dc4..bf0955223490 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/reservation/reservation_013_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/reservation/reservation_013_pos.ksh
	@@ -1,112 +1,112 @@
	#!/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:
	#
	# Reservation properties on data objects should be preserved when the
	# pool within which they are contained is exported and then re-imported.
	#
	#
	# STRATEGY:
	# 1) Create a filesystem as dataset
	# 2) Create another filesystem at the same level
	# 3) Create a regular volume at the same level
	# 4) Create a sparse volume at the same level
	# 5) Create a filesystem within the dataset filesystem
	# 6) Set reservations on all filesystems
	# 7) Export the pool
	# 8) Re-import the pool
	# 9) Verify that the reservation settings are correct
	#

	verify_runnable "global"

	log_assert "Reservation properties preserved across exports and imports"

	function cleanup
	{
	for obj in $OBJ_LIST; do
	- datasetexists $obj && log_must zfs destroy -f $obj
	+ datasetexists $obj && destroy_dataset $obj -f
	done

	log_must zero_reservation $TESTPOOL/$TESTFS
	}
	log_onexit cleanup

	OBJ_LIST="$TESTPOOL/$TESTFS1/$TESTFS2 $TESTPOOL/$TESTFS1 $TESTPOOL/$TESTVOL \
	$TESTPOOL/$TESTVOL2"

	log_must zfs create $TESTPOOL/$TESTFS1
	log_must zfs create $TESTPOOL/$TESTFS1/$TESTFS2

	space_avail=$(get_prop available $TESTPOOL)
	[[ $? -ne 0 ]] && \
	log_fail "Unable to get space available property for $TESTPOOL"

	typeset -il resv_set=space_avail/5
	resv_set=$(floor_volsize $resv_set)
	typeset -il sparse_vol_set_size=space_avail*5
	sparse_vol_set_size=$(floor_volsize $sparse_vol_set_size)

	# When initially created, a regular volume's reservation property is set
	# equal to its size (unlike a sparse volume), so we don't need to set it
	# explicitly later on
	log_must zfs create -V $resv_set $TESTPOOL/$TESTVOL
	log_must zfs create -s -V $sparse_vol_set_size $TESTPOOL/$TESTVOL2

	log_must zfs set reservation=$resv_set $TESTPOOL/$TESTFS
	log_must zfs set reservation=$resv_set $TESTPOOL/$TESTFS1
	log_must zfs set reservation=$resv_set $TESTPOOL/$TESTFS1/$TESTFS2
	log_must zfs set reservation=$resv_set $TESTPOOL/$TESTVOL2

	-log_must zpool export $TESTPOOL
	+log_must_busy zpool export $TESTPOOL
	log_must zpool import $TESTPOOL

	for obj in $TESTPOOL/$TESTFS $OBJ_LIST; do

	if [[ $obj == $TESTPOOL/$TESTVOL ]]; then
	expected=$(volsize_to_reservation $obj $resv_set)
	found=$(get_prop refreservation $obj)
	else
	expected=$resv_set
	found=$(get_prop reservation $obj)
	fi

	[[ $found != $expected ]] && \
	log_fail "Reservation property for $obj incorrect. Expected " \
	"$expected but got $found."
	done

	log_pass "Reservation properties preserved across exports and imports"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/reservation/reservation_014_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/reservation/reservation_014_pos.ksh
	index e8bd91d00e68..3b7f384da365 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/reservation/reservation_014_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/reservation/reservation_014_pos.ksh
	@@ -1,116 +1,116 @@
	#!/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:
	#
	# A reservation cannot exceed the quota on a dataset
	#
	# STRATEGY:
	# 1) Create a filesystem and volume
	# 2) Set a quota on the filesystem
	# 3) Attempt to set a reservation larger than the quota. Verify
	# that the attempt fails.
	# 4) Repeat 2-3 for volume
	#

	verify_runnable "both"

	log_assert "Verify cannot set reservation larger than quota"

	function cleanup
	{
	#
	# Note we don't destroy $TESTFS as it's used by other tests
	for obj in $OBJ_LIST ; do
	- datasetexists $obj && log_must zfs destroy -f $obj
	+ datasetexists $obj && destroy_dataset $obj -f
	done

	log_must zero_reservation $TESTPOOL/$TESTFS
	}
	log_onexit cleanup

	space_avail=`get_prop available $TESTPOOL`

	if ! is_global_zone ; then
	OBJ_LIST=""
	else
	OBJ_LIST="$TESTPOOL/$TESTVOL $TESTPOOL/$TESTVOL2"

	((vol_set_size = space_avail / 4))
	vol_set_size=$(floor_volsize $vol_set_size)
	((sparse_vol_set_size = space_avail * 4))
	sparse_vol_set_size=$(floor_volsize $sparse_vol_set_size)

	log_must zfs create -V $vol_set_size $TESTPOOL/$TESTVOL
	log_must zfs create -s -V $sparse_vol_set_size $TESTPOOL/$TESTVOL2
	fi

	for obj in $TESTPOOL/$TESTFS $OBJ_LIST ; do

	space_avail=`get_prop available $obj`
	((quota_set_size = space_avail / 3))

	#
	# Volumes do not support quota so only need to explicitly
	# set quotas for filesystems.
	#
	# The maximum reservation value that can be set on a volume
	# is determined by the quota set on its parent filesystems or
	# the amount of space in the pool, whichever is smaller.
	#
	if [[ $obj == $TESTPOOL/$TESTFS ]]; then
	log_must zfs set quota=$quota_set_size $obj
	((resv_set_size = quota_set_size + RESV_SIZE))
	elif [[ $obj == $TESTPOOL/$TESTVOL \|\| $obj == $TESTPOOL/$TESTVOL2 ]]
	then
	resv_set_size=`expr $space_avail + $RESV_DELTA`
	fi

	orig_quota=`get_prop quota $obj`

	log_mustnot zfs set reservation=$resv_set_size $obj
	new_quota=`get_prop quota $obj`

	if [[ $orig_quota != $new_quota ]]; then
	log_fail "Quota value changed from $orig_quota " \
	"to $new_quota"
	fi

	if [[ $obj == $TESTPOOL/$TESTFS ]]; then
	log_must zfs set quota=none $obj
	fi
	done

	log_pass "As expected cannot set reservation larger than quota"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/reservation/reservation_015_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/reservation/reservation_015_pos.ksh
	index d67f8c7ec2f6..7067a7810590 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/reservation/reservation_015_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/reservation/reservation_015_pos.ksh
	@@ -1,99 +1,100 @@
	#!/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:
	#
	# In pool with a full filesystem and a regular volume with an implicit
	# reservation, setting the reservation on the volume to 'none' should allow
	# more data to be written to the filesystem.
	#
	#
	# STRATEGY:
	# 1) Create a regular non-sparse volume (which implicitly sets the reservation
	# property to a value equal to the volume size)
	# 2) Create a filesystem at the same level
	# 3) Fill up the filesystem
	# 4) Set the reservation on the volume to 'none'
	# 5) Verify can write more data to the filesystem
	#

	verify_runnable "global"

	log_assert "Setting volume reservation to 'none' allows more data to be " \
	"written to top level filesystem"

	function cleanup
	{
	datasetexists $TESTPOOL/$TESTVOL && \
	- log_must zfs destroy $TESTPOOL/$TESTVOL
	+ destroy_dataset $TESTPOOL/$TESTVOL

	[[ -e $TESTDIR/$TESTFILE1 ]] && log_must rm -rf $TESTDIR/$TESTFILE1
	[[ -e $TESTDIR/$TESTFILE2 ]] && log_must rm -rf $TESTDIR/$TESTFILE2
	}
	log_onexit cleanup

	space_avail=$(largest_volsize_from_pool $TESTPOOL)

	#
	# To make sure this test doesn't take too long to execute on
	# large pools, we calculate a volume size which when applied
	# to the volume will ensure we have RESV_FREE_SPACE
	# left free in the pool which we can quickly fill.
	#
	((resv_size_set = space_avail - RESV_FREE_SPACE))
	resv_size_set=$(floor_volsize $resv_size_set)

	log_must zfs create -V $resv_size_set $TESTPOOL/$TESTVOL
	+block_device_wait $TESTPOOL/$TESTVOL

	space_avail_still=`get_prop available $TESTPOOL`

	fill_size=$((space_avail_still + $RESV_TOLERANCE))
	write_count=$((fill_size / BLOCK_SIZE))

	# Now fill up the filesystem (which doesn't have a reservation set
	# and thus will use up whatever free space is left in the pool).
	file_write -o create -f $TESTDIR/$TESTFILE1 -b $BLOCK_SIZE -c $write_count -d 0
	ret=$?
	if (($ret != $ENOSPC)); then
	log_fail "Did not get ENOSPC as expected (got $ret)."
	fi

	log_must zfs set refreservation=none $TESTPOOL/$TESTVOL

	log_must file_write -o create -f $TESTDIR/$TESTFILE2 \
	-b $(getconf PAGESIZE) -c 1000 -d 0

	log_pass "Setting top level volume reservation to 'none' allows more " \
	"data to be written to the top level filesystem"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/reservation/reservation_016_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/reservation/reservation_016_pos.ksh
	index cbb1db658b33..82bbcde4a3b7 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/reservation/reservation_016_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/reservation/reservation_016_pos.ksh
	@@ -1,98 +1,99 @@
	#!/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/reservation/reservation.shlib

	#
	# DESCRIPTION:
	#
	# In pool with a full filesystem and a regular volume (with implicit
	# reservation) destroying the volume should allow more data to be written
	# to the filesystem
	#
	#
	# STRATEGY:
	# 1) Create a regular (non-sparse) volume
	# 2) Create a filesystem at the same level
	# 3) Fill up the filesystem
	# 4) Destroy the volume
	# 5) Verify can write more data to the filesystem
	#

	verify_runnable "global"

	log_assert "Destroying a regular volume with reservation allows more data to" \
	" be written to top level filesystem"

	function cleanup
	{
	datasetexists $TESTPOOL/$TESTVOL && \
	- log_must zfs destroy $TESTPOOL/$TESTVOL
	+ destroy_dataset $TESTPOOL/$TESTVOL

	[[ -e $TESTDIR/$TESTFILE1 ]] && log_must rm -rf $TESTDIR/$TESTFILE1
	[[ -e $TESTDIR/$TESTFILE2 ]] && log_must rm -rf $TESTDIR/$TESTFILE2
	}
	log_onexit cleanup

	space_avail=$(largest_volsize_from_pool $TESTPOOL)

	#
	# To make sure this test doesn't take too long to execute on
	# large pools, we calculate a volume size which will ensure we
	# have RESV_FREE_SPACE left free in the pool.
	#
	((vol_set_size = space_avail - RESV_FREE_SPACE))
	vol_set_size=$(floor_volsize $vol_set_size)

	# Creating a regular volume implicitly sets its reservation
	# property to the same value.
	log_must zfs create -V $vol_set_size $TESTPOOL/$TESTVOL
	+block_device_wait $TESTPOOL/$TESTVOL

	space_avail_still=$(get_prop available $TESTPOOL)
	fill_size=$((space_avail_still + $RESV_TOLERANCE))
	write_count=$((fill_size / BLOCK_SIZE))

	# Now fill up the filesystem (which doesn't have a reservation set
	# and thus will use up whatever free space is left in the pool).
	file_write -o create -f $TESTDIR/$TESTFILE1 -b $BLOCK_SIZE -c $write_count -d 0
	ret=$?
	if (($ret != $ENOSPC)); then
	log_fail "Did not get ENOSPC as expected (got $ret)."
	fi

	log_must zfs destroy -f $TESTPOOL/$TESTVOL

	log_must file_write -o create -f $TESTDIR/$TESTFILE2 \
	-b $(getconf PAGESIZE) -c 1000 -d 0

	log_pass "Destroying volume with reservation allows more data to be written " \
	"to top level filesystem"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/reservation/reservation_018_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/reservation/reservation_018_pos.ksh
	index 0969a6877316..1f92c8898562 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/reservation/reservation_018_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/reservation/reservation_018_pos.ksh
	@@ -1,72 +1,72 @@
	#!/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:
	#
	# Verify that reservation doesn't inherit its value from parent.
	#
	# STRATEGY:
	# 1) Create a filesystem tree
	# 2) Set reservation for parents
	# 3) Verify that the 'reservation' for descendent doesnot inherit the value.
	#

	verify_runnable "both"

	function cleanup
	{
	- datasetexists $fs_child && log_must zfs destroy $fs_child
	+ datasetexists $fs_child && destroy_dataset $fs_child
	log_must zfs set reservation=$reserv_val $fs
	}

	log_onexit cleanup

	log_assert "Verify that reservation doesnot inherit its value from parent."

	fs=$TESTPOOL/$TESTFS
	fs_child=$TESTPOOL/$TESTFS/$TESTFS

	space_avail=$(get_prop available $fs)
	reserv_val=$(get_prop reservation $fs)
	typeset reservsize=$space_avail
	((reservsize = reservsize / 2))
	log_must zfs set reservation=$reservsize $fs

	log_must zfs create $fs_child
	rsv_space=$(get_prop reservation $fs_child)
	[[ $rsv_space == $reservsize ]] && \
	log_fail "The reservation of child dataset inherits its value from parent."

	log_pass "reservation doesnot inherit its value from parent as expected."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/rsend/send-c_lz4_disabled.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/rsend/send-c_lz4_disabled.ksh
	index 666e11f702f8..bc706bab25b8 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/rsend/send-c_lz4_disabled.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/rsend/send-c_lz4_disabled.ksh
	@@ -1,73 +1,73 @@
	#!/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) 2015 by Delphix. All rights reserved.
	#

	. $STF_SUITE/tests/functional/rsend/rsend.kshlib

	#
	# Description:
	# Verify a pool without the lz4 feature enabled can create compressed send
	# streams, and that they can be received into pools with or without the
	# lz4 feature.
	#
	# Strategy:
	# 1. For each of an uncompressed, and gzip dataset created from a pool with
	# the lz4 feature disabled, receive the stream into a pool with and without
	# the feature enabled.
	#

	verify_runnable "both"

	log_assert "Verify compressed streams are rejected if incompatible."

	typeset send_ds=$POOL2/testds
	typeset recv_ds=$POOL3/testds

	function cleanup
	{
	poolexists $POOL2 && destroy_pool $POOL2
	poolexists $POOL3 && destroy_pool $POOL3
	log_must zpool create $POOL2 $DISK2
	}
	log_onexit cleanup

	datasetexists $POOL2 && log_must zpool destroy $POOL2
	log_must zpool create -d $POOL2 $DISK2

	for compress in off gzip; do
	for pool_opt in '' -d; do
	poolexists $POOL3 && destroy_pool $POOL3
	log_must zpool create $pool_opt $POOL3 $DISK3

	- datasetexists $send_ds && log_must_busy zfs destroy -r $send_ds
	- datasetexists $recv_ds && log_must_busy zfs destroy -r $recv_ds
	+ datasetexists $send_ds && destroy_dataset $send_ds -r
	+ datasetexists $recv_ds && destroy_dataset $recv_ds -r

	log_must zfs create -o compress=$compress $send_ds
	typeset dir=$(get_prop mountpoint $send_ds)
	write_compressible $dir 16m
	log_must zfs snapshot $send_ds@full

	log_must eval "zfs send -c $send_ds@full >$BACKDIR/full-c"
	log_must eval "zfs recv $recv_ds <$BACKDIR/full-c"

	log_must_busy zfs destroy -r $recv_ds

	log_must eval "zfs send $send_ds@full >$BACKDIR/full"
	log_must eval "zfs recv $recv_ds <$BACKDIR/full"
	done
	done

	log_pass "Compressed streams are rejected if incompatible."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/rsend/send-c_recv_lz4_disabled.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/rsend/send-c_recv_lz4_disabled.ksh
	index 20a8c5481224..15873ed12f1e 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/rsend/send-c_recv_lz4_disabled.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/rsend/send-c_recv_lz4_disabled.ksh
	@@ -1,68 +1,68 @@
	#!/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) 2015, Delphix. All rights reserved.
	#

	. $STF_SUITE/tests/functional/rsend/rsend.kshlib
	. $STF_SUITE/include/properties.shlib

	#
	# Description:
	# Verify a pool without the lz4 feature gracefully rejects a compressed stream
	# because on any sending pool that supports it, metadata will be compressed
	# with lz4 even if user data is not compressed.
	#
	# Strategy:
	# 1. For each of an uncompressed, gzip and lz4 dataset, do the following
	# receives into a pool without the lz4 feature:
	# 2. Attempt to receive the compressed stream (should fail)
	# 3. Attempt to receive the uncompressed stream (should succeed)
	#

	verify_runnable "both"

	log_assert "Verify compressed streams are rejected if incompatible."

	typeset send_ds=$POOL2/testds
	typeset recv_ds=$POOL3/testds

	function cleanup
	{
	poolexists $POOL2 && destroy_pool $POOL2
	poolexists $POOL3 && destroy_pool $POOL3
	log_must zpool create $POOL2 $DISK2
	}
	log_onexit cleanup

	datasetexists $POOL3 && log_must zpool destroy $POOL3
	log_must zpool create -d $POOL3 $DISK3

	for compress in "${compress_prop_vals[@]}"; do
	- datasetexists $send_ds && log_must_busy zfs destroy -r $send_ds
	- datasetexists $recv_ds && log_must_busy zfs destroy -r $recv_ds
	+ datasetexists $send_ds && destroy_dataset $send_ds -r
	+ datasetexists $recv_ds && destroy_dataset $recv_ds -r

	log_must zfs create -o compress=$compress $send_ds
	typeset dir=$(get_prop mountpoint $send_ds)
	write_compressible $dir 16m
	log_must zfs snapshot $send_ds@full

	log_must eval "zfs send -c $send_ds@full >$BACKDIR/full-c"
	log_mustnot eval "zfs recv $recv_ds <$BACKDIR/full-c"

	log_must eval "zfs send $send_ds@full >$BACKDIR/full"
	log_must eval "zfs recv $recv_ds <$BACKDIR/full"
	done

	log_pass "Compressed streams are rejected if incompatible."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/rsend/send-c_stream_size_estimate.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/rsend/send-c_stream_size_estimate.ksh
	index b3edb1c45788..056fc2cc2584 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/rsend/send-c_stream_size_estimate.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/rsend/send-c_stream_size_estimate.ksh
	@@ -1,97 +1,97 @@
	#!/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) 2015, Delphix. All rights reserved.
	#

	. $STF_SUITE/tests/functional/rsend/rsend.kshlib
	. $STF_SUITE/include/properties.shlib

	#
	# Description:
	# Verify the stream size estimate given by -P accounts for compressed send.
	# Verify the stream size given by -P accounts for compressed send."
	#
	# Strategy:
	# 1. For datasets of varied compression types do the following:
	# 2. Write data, verify stream size estimates with and without -c
	#

	verify_runnable "both"
	typeset send_ds="$POOL2/testfs"
	typeset send_vol="$POOL2/vol"
	typeset send_voldev="$ZVOL_DEVDIR/$POOL2/vol"
	typeset file="$BACKDIR/file.0"
	typeset megs="16"
	typeset compress

	function get_estimated_size
	{
	typeset cmd=$1
	typeset ds=${cmd##* }
	if is_freebsd; then
	mkdir -p $BACKDIR
	typeset tmpfile=$(TMPDIR=$BACKDIR mktemp)
	else
	typeset tmpfile=$(mktemp -p $BACKDIR)
	fi

	eval "$cmd >$tmpfile"
	[[ $? -eq 0 ]] \|\| log_fail "get_estimated_size: $cmd"
	typeset size=$(eval "awk '\$2 == \"$ds\" {print \$3}' $tmpfile")
	rm -f $tmpfile

	echo $size
	}

	log_assert "Verify the stream size given by -P accounts for compressed send."
	log_onexit cleanup_pool $POOL2

	write_compressible $BACKDIR ${megs}m

	for compress in "${compress_prop_vals[@]}"; do
	- datasetexists $send_ds && log_must_busy zfs destroy -r $send_ds
	- datasetexists $send_vol && log_must_busy zfs destroy -r $send_vol
	+ datasetexists $send_ds && destroy_dataset $send_ds -r
	+ datasetexists $send_vol && destroy_dataset $send_vol -r
	log_must zfs create -o compress=$compress $send_ds
	log_must zfs create -V 1g -o compress=$compress $send_vol
	block_device_wait $send_voldev

	typeset dir=$(get_prop mountpoint $send_ds)
	log_must cp $file $dir
	log_must zfs snapshot $send_ds@snap
	log_must dd if=$file of=$send_voldev
	log_must zfs snapshot $send_vol@snap

	typeset ds_size=$(get_estimated_size "zfs send -nP $send_ds@snap")
	typeset ds_lrefer=$(get_prop lrefer $send_ds)
	within_percent $ds_size $ds_lrefer 90 \|\| log_fail \
	"$ds_size and $ds_lrefer differed by too much"

	typeset vol_size=$(get_estimated_size "zfs send -nP $send_vol@snap")
	typeset vol_lrefer=$(get_prop lrefer $send_vol)
	within_percent $vol_size $vol_lrefer 90 \|\| log_fail \
	"$vol_size and $vol_lrefer differed by too much"

	typeset ds_csize=$(get_estimated_size "zfs send -nP -c $send_ds@snap")
	typeset ds_refer=$(get_prop refer $send_ds)
	within_percent $ds_csize $ds_refer 90 \|\| log_fail \
	"$ds_csize and $ds_refer differed by too much"

	typeset vol_csize=$(get_estimated_size "zfs send -nP -c $send_vol@snap")
	typeset vol_refer=$(get_prop refer $send_vol)
	within_percent $vol_csize $vol_refer 90 \|\| log_fail \
	"$vol_csize and $vol_refer differed by too much"
	done

	log_pass "The stream size given by -P accounts for compressed send."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/rsend/send-cpL_varied_recsize.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/rsend/send-cpL_varied_recsize.ksh
	index e2810651a60e..25ad8e0820d1 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/rsend/send-cpL_varied_recsize.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/rsend/send-cpL_varied_recsize.ksh
	@@ -1,203 +1,203 @@
	#!/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) 2015 by Delphix. All rights reserved.
	#

	. $STF_SUITE/tests/functional/rsend/rsend.kshlib

	#
	# Description:
	# Verify compressed send works correctly with datasets of varying recsize.
	#
	# Strategy:
	# 1. Check the recv behavior (into pools with features enabled and disabled)
	# of all combinations of -c -p and -L. Verify the stream is compressed,
	# and that the recsize property and that of a received file is correct
	# according to this matrix:
	#
	# +---------+--------+------------+------------+-----------+-----------+
	# \| send \| send \| received \| received \| received \| received \|
	# \| stream \| stream \| file bs \| prop \| file bs \| props \|
	# \| recsize \| flags \| (disabled) \| (disabled) \| (enabled) \| (enabled) \|
	# +---------+--------+------------+------------+-----------+-----------+
	# \| 128k \| \| 128k \| 128k \| 128k \| 128k \|
	# \| 128k \| -c \| Fails \| Fails \| 128k \| 128k \|
	# \| 128k \| -p \| 128k \| 128k \| 128k \| 128k \|
	# \| 128k \| -L \| 128k \| 128k \| 128k \| 128k \|
	# \| 128k \| -cp \| Fails \| Fails \| 128k \| 128k \|
	# \| 128k \| -cL \| Fails \| Fails \| 128k \| 128k \|
	# \| 128k \| -pL \| 128k \| 128k \| 128k \| 128k \|
	# \| 128k \| -cpL \| Fails \| Fails \| 128k \| 128k \|
	# \| 1m \| \| Fails \| Fails \| 128k \| 128k \|
	# \| 1m \| -c \| Fails \| Fails \| 128k \| 128k \|
	# \| 1m \| -p \| 128k \| 128k \| 128k \| 1m \|
	# \| 1m \| -L \| Fails \| Fails \| 1m \| 128k \|
	# \| 1m \| -cp \| Fails \| Fails \| 128k \| 1m \|
	# \| 1m \| -cL \| Fails \| Fails \| 1m \| 128k \|
	# \| 1m \| -pL \| Fails \| Fails \| 1m \| 1m \|
	# \| 1m \| -cpL \| Fails \| Fails \| 1m \| 1m \|
	# +---------+--------+------------+------------+-----------+-----------+
	#

	verify_runnable "both"

	function cleanup
	{
	- datasetexists $TESTPOOL/128k && log_must_busy zfs destroy $TESTPOOL/128k
	- datasetexists $TESTPOOL/1m && log_must_busy zfs destroy $TESTPOOL/1m
	+ datasetexists $TESTPOOL/128k && destroy_dataset $TESTPOOL/128k
	+ datasetexists $TESTPOOL/1m && destroy_dataset $TESTPOOL/1m
	cleanup_pool $POOL2
	destroy_pool $POOL3
	}

	# For a received stream, verify the recsize (prop and file) match expectations.
	function check_recsize
	{
	typeset recv_ds=$1
	typeset expected_file_bs=$2
	typeset expected_recsize=$3
	typeset file="$(get_prop mountpoint $recv_ds)/testfile"

	[[ -f $file ]] \|\| log_fail "file '$file' doesn't exist"

	typeset read_recsize=$(get_prop recsize $recv_ds)
	if is_freebsd; then
	typeset read_file_bs=$(stat -f "%k" $file)
	else
	typeset read_file_bs=$(stat $file \| sed -n \
	's/.IO Block: $[0-9]$.*/\1/p')
	fi

	[[ $read_recsize = $expected_recsize ]] \|\| log_fail \
	"read_recsize: $read_recsize expected_recsize: $expected_recsize"
	[[ $read_file_bs = $expected_file_bs ]] \|\| log_fail \
	"read_file_bs: $read_file_bs expected_file_bs: $expected_file_bs"
	}

	#
	# This function does a zfs send and receive according to the parameters
	# below, and verifies the data shown in the strategy section.
	#
	# -[cpL] flags to pass through to 'zfs send'
	# -d Receive into a pool with all features disabled
	#
	# $1 The recordsize of the send dataset
	# $2 Whether or not the recv should work.
	# $3 The blocksize expected in a received file (default 128k)
	# $4 The recordsize property expected in a received dataset (default 128k)
	#
	function check
	{
	typeset recv_pool=$POOL2
	typeset flags='-'

	while getopts "cdpL" opt; do
	case $opt in
	c)
	flags+='c'
	;;
	d)
	recv_pool=$POOL3
	;;
	p)
	flags+='p'
	;;
	L)
	flags+='L'
	;;
	esac
	done
	shift $(($OPTIND - 1))
	[[ ${#flags} -eq 1 ]] && flags=''

	typeset recsize=$1
	typeset verify=$2
	typeset expected_file_bs=${3-131072}
	typeset expected_recsize=${4-131072}
	typeset send_ds=$TESTPOOL/$recsize
	typeset send_snap=$send_ds@snap
	typeset recv_ds=$recv_pool/$recsize
	typeset stream=$BACKDIR/stream.out

	datasetexists $send_ds \|\| log_fail "send ds: $send_ds doesn't exist"
	[[ -f $stream ]] && log_must rm $stream
	log_must eval "zfs send $flags $send_snap >$stream"
	$verify eval "zfs recv $recv_ds <$stream"
	typeset stream_size=$(cat $stream \| zstream dump \| sed -n \
	's/ Total write size = $.$ (0x.)/\1/p')

	#
	# Special case: For a send dataset with large blocks, don't try to
	# verify the stream size is correct if the compress flag is present
	# but the large blocks flag isn't. In these cases, the user data
	# isn't compressed in the stream (though metadata is) so the
	# verification would fail.
	#
	typeset do_size_test=true
	[[ $recsize = $large && $flags =~ 'c' && ! $flags =~ 'L' ]] && \
	do_size_test=false

	$do_size_test && verify_stream_size $stream $send_ds

	if [[ $verify = "log_mustnot" ]]; then
	datasetnonexists $recv_ds \|\| log_fail "$recv_ds shouldn't exist"
	return
	fi

	check_recsize $recv_ds $expected_file_bs $expected_recsize
	$do_size_test && verify_stream_size $stream $recv_ds
	log_must_busy zfs destroy -r $recv_ds
	}

	log_assert "Verify compressed send works with datasets of varying recsize."
	log_onexit cleanup
	typeset recsize opts dir
	typeset small=$((128 * 1024))
	typeset large=$((1024 * 1024))

	# Create POOL3 with features disabled and datasets to create test send streams
	datasetexists $POOL3 && log_must zpool destroy $POOL3
	log_must zpool create -d $POOL3 $DISK3
	write_compressible $BACKDIR 32m
	for recsize in $small $large; do
	log_must zfs create -o compress=gzip -o recsize=$recsize \
	$TESTPOOL/$recsize
	dir=$(get_prop mountpoint $TESTPOOL/$recsize)
	log_must cp $BACKDIR/file.0 $dir/testfile
	log_must zfs snapshot $TESTPOOL/$recsize@snap
	done

	# Run tests for send streams without large blocks
	for opts in '' -d -c -p -dp -L -dL -cp -cL -pL -dpL -cpL; do
	check $opts $small log_must
	done
	for opts in -dc -dcp -dcL -dcpL; do
	check $opts $small log_mustnot
	done

	# Run tests for send streams with large blocks
	for opts in '' -d -dp -c; do
	check $opts $large log_must
	done
	for opts in -dc -dL -dcp -dcL -dpL -dcpL; do
	check $opts $large log_mustnot
	done
	check -p $large log_must $small $large
	check -L $large log_must $large $small
	check -cp $large log_must $small $large
	check -cL $large log_must $large $small
	check -pL $large log_must $large $large
	check -cpL $large log_must $large $large

	log_pass "Compressed send works with datasets of varying recsize."
	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 1fd21cbf7eff..370f5382ebae 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
	+ destroy_dataset $TESTPOOL/$TESTFS2 -r
	datasetexists $TESTPOOL/recv && \
	- log_must zfs destroy -r $TESTPOOL/recv
	+ destroy_dataset $TESTPOOL/recv -r
	[[ -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

	# 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/rsend/send_encrypted_truncated_files.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/rsend/send_encrypted_truncated_files.ksh
	index c710b3d911e7..5760bf9b902a 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/rsend/send_encrypted_truncated_files.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/rsend/send_encrypted_truncated_files.ksh
	@@ -1,126 +1,126 @@
	#!/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:
	#
	#
	# STRATEGY:
	# 1. Create a new encrypted filesystem
	# 2. Add a 4 files that are to be truncated later
	# 3. Take a snapshot of the filesystem
	# 4. Truncate one of the files from 32M to 128k
	# 5. Truncate one of the files from 512k to 384k
	# 6. Truncate one of the files from 512k to 0 to 384k via reallocation
	# 7. Truncate one of the files from 1k to 0 to 512b via reallocation
	# 8. Take another snapshot of the filesystem
	# 9. Send and receive both snapshots
	# 10. Mount the filesystem and check the contents
	#

	verify_runnable "both"

	function cleanup
	{
	datasetexists $TESTPOOL/$TESTFS2 && \
	- log_must zfs destroy -r $TESTPOOL/$TESTFS2
	+ destroy_dataset $TESTPOOL/$TESTFS2 -r
	datasetexists $TESTPOOL/recv && \
	- log_must zfs destroy -r $TESTPOOL/recv
	+ destroy_dataset $TESTPOOL/recv -r
	[[ -f $keyfile ]] && log_must rm $keyfile
	[[ -f $sendfile ]] && log_must rm $sendfile
	}
	log_onexit cleanup

	function recursive_cksum
	{
	case "$(uname)" in
	FreeBSD)
	find $1 -type f -exec sha256 -q {} \; \| \
	sort \| sha256digest
	;;
	*)
	find $1 -type f -exec sha256sum {} \; \| \
	sort -k 2 \| awk '{ print $1 }' \| sha256digest
	;;
	esac
	}

	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

	# Explicitly set the recordsize since the truncation sizes below depend on
	# this value being 128k. This is currently same as the default recordsize.
	log_must zfs set recordsize=128k $TESTPOOL/$TESTFS2

	# Create files with varied layouts on disk
	log_must mkfile 32M /$TESTPOOL/$TESTFS2/truncated
	log_must mkfile 524288 /$TESTPOOL/$TESTFS2/truncated2
	log_must mkfile 524288 /$TESTPOOL/$TESTFS2/truncated3
	log_must mkfile 1024 /$TESTPOOL/$TESTFS2/truncated4

	log_must zfs snapshot $TESTPOOL/$TESTFS2@snap1

	#
	# Truncate files created in the first snapshot. The first tests
	# truncating a large file to a single block. The second tests
	# truncating one block off the end of a file without changing
	# the required nlevels to hold it. The third tests handling
	# of a maxblkid that is dropped and then raised again. The
	# fourth tests an object that is truncated from a single block
	# to a smaller single block.
	#
	log_must truncate -s 131072 /$TESTPOOL/$TESTFS2/truncated
	log_must truncate -s 393216 /$TESTPOOL/$TESTFS2/truncated2
	log_must rm -f /$TESTPOOL/$TESTFS2/truncated3
	log_must rm -f /$TESTPOOL/$TESTFS2/truncated4
	log_must zpool sync $TESTPOOL
	log_must zfs umount $TESTPOOL/$TESTFS2
	log_must zfs mount $TESTPOOL/$TESTFS2
	log_must dd if=/dev/urandom of=/$TESTPOOL/$TESTFS2/truncated3 \
	bs=128k count=3 iflag=fullblock
	log_must dd if=/dev/urandom of=/$TESTPOOL/$TESTFS2/truncated4 \
	bs=512 count=1 iflag=fullblock

	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_pass "Verified 'zfs send -w' works with many different file layouts"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/rsend/send_mixed_raw.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/rsend/send_mixed_raw.ksh
	index eea535af1100..59b08ccf723b 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/rsend/send_mixed_raw.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/rsend/send_mixed_raw.ksh
	@@ -1,118 +1,118 @@
	#!/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

	#
	# DESCRIPTION:
	# Verify that 'zfs receive' produces an error when mixing
	# raw and non-raw sends in a way that would break IV set
	# consistency.
	#
	# STRATEGY:
	# 1. Create an initial dataset with 3 snapshots.
	# 2. Perform a raw send of the first snapshot to 2 other datasets.
	# 3. Perform a non-raw send of the second snapshot to one of
	# the other datasets. Perform a raw send from this dataset to
	# the last one.
	# 4. Attempt to raw send the final snapshot of the first dataset
	# to the other 2 datasets, which should fail.
	# 5. Repeat steps 1-4, but using bookmarks for incremental sends.
	#
	#
	# A B C notes
	# ------------------------------------------------------------------------------
	# snap1 ---raw---> snap1 --raw--> snap1 # all snaps initialized via raw send
	# snap2 -non-raw-> snap2 --raw--> snap2 # A sends non-raw to B, B sends raw to C
	# snap3 ------------raw---------> snap3 # attempt send to C (should fail)
	#


	verify_runnable "both"

	function cleanup
	{
	datasetexists $TESTPOOL/$TESTFS3 && \
	- log_must zfs destroy -r $TESTPOOL/$TESTFS3
	+ destroy_dataset $TESTPOOL/$TESTFS3 -r
	datasetexists $TESTPOOL/$TESTFS2 && \
	- log_must zfs destroy -r $TESTPOOL/$TESTFS2
	+ destroy_dataset $TESTPOOL/$TESTFS2 -r
	datasetexists $TESTPOOL/$TESTFS1 && \
	- log_must zfs destroy -r $TESTPOOL/$TESTFS1
	+ destroy_dataset $TESTPOOL/$TESTFS1 -r
	}
	log_onexit cleanup

	log_assert "Mixing raw and non-raw receives should fail"

	typeset passphrase="password"

	log_must eval "echo $passphrase \| zfs create -o encryption=on" \
	"-o keyformat=passphrase $TESTPOOL/$TESTFS1"

	log_must zfs snapshot $TESTPOOL/$TESTFS1@1
	log_must touch /$TESTPOOL/$TESTFS1/a
	log_must zfs snapshot $TESTPOOL/$TESTFS1@2
	log_must touch /$TESTPOOL/$TESTFS1/b
	log_must zfs snapshot $TESTPOOL/$TESTFS1@3

	# Testing with snapshots
	log_must eval "zfs send -w $TESTPOOL/$TESTFS1@1 \|" \
	"zfs receive $TESTPOOL/$TESTFS2"
	log_must eval "echo $passphrase \| zfs load-key $TESTPOOL/$TESTFS2"
	log_must eval "zfs send -w $TESTPOOL/$TESTFS2@1 \|" \
	"zfs receive $TESTPOOL/$TESTFS3"
	log_must eval "echo $passphrase \| zfs load-key $TESTPOOL/$TESTFS3"

	log_must eval "zfs send -i $TESTPOOL/$TESTFS1@1 $TESTPOOL/$TESTFS1@2 \|" \
	"zfs receive $TESTPOOL/$TESTFS2"
	log_must eval "zfs send -w -i $TESTPOOL/$TESTFS2@1 $TESTPOOL/$TESTFS2@2 \|" \
	"zfs receive $TESTPOOL/$TESTFS3"

	log_mustnot eval "zfs send -w -i $TESTPOOL/$TESTFS1@2 $TESTPOOL/$TESTFS1@3 \|" \
	"zfs receive $TESTPOOL/$TESTFS2"
	log_mustnot eval "zfs send -w -i $TESTPOOL/$TESTFS2@2 $TESTPOOL/$TESTFS2@3 \|" \
	"zfs receive $TESTPOOL/$TESTFS3"

	log_must zfs destroy -r $TESTPOOL/$TESTFS3
	log_must zfs destroy -r $TESTPOOL/$TESTFS2

	# Testing with bookmarks
	log_must zfs bookmark $TESTPOOL/$TESTFS1@1 $TESTPOOL/$TESTFS1#b1
	log_must zfs bookmark $TESTPOOL/$TESTFS1@2 $TESTPOOL/$TESTFS1#b2

	log_must eval "zfs send -w $TESTPOOL/$TESTFS1@1 \|" \
	"zfs receive $TESTPOOL/$TESTFS2"
	log_must eval "echo $passphrase \| zfs load-key $TESTPOOL/$TESTFS2"

	log_must zfs bookmark $TESTPOOL/$TESTFS2@1 $TESTPOOL/$TESTFS2#b1

	log_must eval "zfs send -w $TESTPOOL/$TESTFS2@1 \|" \
	"zfs receive $TESTPOOL/$TESTFS3"
	log_must eval "echo $passphrase \| zfs load-key $TESTPOOL/$TESTFS3"

	log_must eval "zfs send -i $TESTPOOL/$TESTFS1#b1 $TESTPOOL/$TESTFS1@2 \|" \
	"zfs receive $TESTPOOL/$TESTFS2"
	log_must eval "zfs send -w -i $TESTPOOL/$TESTFS2#b1 $TESTPOOL/$TESTFS2@2 \|" \
	"zfs receive $TESTPOOL/$TESTFS3"

	log_mustnot eval "zfs send -w -i $TESTPOOL/$TESTFS1#b2" \
	"$TESTPOOL/$TESTFS1@3 \| zfs receive $TESTPOOL/$TESTFS2"
	log_mustnot eval "zfs send -w -i $TESTPOOL/$TESTFS2#b2" \
	"$TESTPOOL/$TESTFS2@3 \| zfs receive $TESTPOOL/$TESTFS3"

	log_pass "Mixing raw and non-raw receives fail as expected"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/rsend/send_realloc_dnode_size.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/rsend/send_realloc_dnode_size.ksh
	index 394fe95bb9b7..551ed15db254 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/rsend/send_realloc_dnode_size.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/rsend/send_realloc_dnode_size.ksh
	@@ -1,112 +1,107 @@
	#!/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) 2017 by Lawrence Livermore National Security, LLC.
	# Copyright (c) 2018 Datto Inc.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/rsend/rsend.kshlib

	#
	# Description:
	# Verify incremental receive properly handles objects with changed
	# dnode slot count.
	#
	# Strategy:
	# 1. Populate a dataset with 1k byte dnodes and snapshot
	# 2. Remove objects, set dnodesize=legacy, and remount dataset so new objects
	# get recycled numbers and formerly "interior" dnode slots get assigned
	# to new objects
	# 3. Remove objects, set dnodesize=2k, and remount dataset so new objects
	# overlap with recently recycled and formerly "normal" dnode slots get
	# assigned to new objects
	# 4. Create an empty file and add xattrs to it to exercise reclaiming a
	# dnode that requires more than 1 slot for its bonus buffer (Zol #7433)
	# 5. Generate initial and incremental streams
	# 6. Verify initial and incremental streams can be received
	#

	verify_runnable "both"

	log_assert "Verify incremental receive handles objects with changed dnode size"

	function cleanup
	{
	rm -f $BACKDIR/fs-dn-legacy
	rm -f $BACKDIR/fs-dn-1k
	rm -f $BACKDIR/fs-dn-2k
	rm -f $BACKDIR/fs-attr

	- if datasetexists $POOL/fs ; then
	- log_must zfs destroy -rR $POOL/fs
	- fi
	-
	- if datasetexists $POOL/newfs ; then
	- log_must zfs destroy -rR $POOL/newfs
	- fi
	+ datasetexists $POOL/fs && destroy_dataset $POOL/fs -rR
	+ datasetexists $POOL/newfs && destroy_dataset $POOL/newfs -rR
	}

	log_onexit cleanup

	# 1. Populate a dataset with 1k byte dnodes and snapshot
	log_must zfs create -o dnodesize=1k $POOL/fs
	log_must mk_files 200 262144 0 $POOL/fs
	log_must zfs snapshot $POOL/fs@a

	# 2. Remove objects, set dnodesize=legacy, and remount dataset so new objects
	# get recycled numbers and formerly "interior" dnode slots get assigned
	# to new objects
	rm /$POOL/fs/*

	log_must zfs unmount $POOL/fs
	log_must zfs set dnodesize=legacy $POOL/fs
	log_must zfs mount $POOL/fs

	log_must mk_files 200 262144 0 $POOL/fs
	log_must zfs snapshot $POOL/fs@b

	# 3. Remove objects, set dnodesize=2k, and remount dataset so new objects
	# overlap with recently recycled and formerly "normal" dnode slots get
	# assigned to new objects
	rm /$POOL/fs/*

	log_must zfs unmount $POOL/fs
	log_must zfs set dnodesize=2k $POOL/fs
	log_must zfs mount $POOL/fs

	log_must touch /$POOL/fs/attrs
	mk_files 200 262144 0 $POOL/fs
	log_must zfs snapshot $POOL/fs@c

	# 4. Create an empty file and add xattrs to it to exercise reclaiming a
	# dnode that requires more than 1 slot for its bonus buffer (Zol #7433)
	log_must zfs set compression=on xattr=sa $POOL/fs
	log_must eval "python -c 'print \"a\" * 512' \|
	set_xattr_stdin bigval /$POOL/fs/attrs"
	log_must zfs snapshot $POOL/fs@d

	# 5. Generate initial and incremental streams
	log_must eval "zfs send $POOL/fs@a > $BACKDIR/fs-dn-1k"
	log_must eval "zfs send -i $POOL/fs@a $POOL/fs@b > $BACKDIR/fs-dn-legacy"
	log_must eval "zfs send -i $POOL/fs@b $POOL/fs@c > $BACKDIR/fs-dn-2k"
	log_must eval "zfs send -i $POOL/fs@c $POOL/fs@d > $BACKDIR/fs-attr"

	# 6. Verify initial and incremental streams can be received
	log_must eval "zfs recv $POOL/newfs < $BACKDIR/fs-dn-1k"
	log_must eval "zfs recv $POOL/newfs < $BACKDIR/fs-dn-legacy"
	log_must eval "zfs recv $POOL/newfs < $BACKDIR/fs-dn-2k"
	log_must eval "zfs recv $POOL/newfs < $BACKDIR/fs-attr"

	log_pass "Verify incremental receive handles objects with changed dnode size"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/snapshot/clone_001_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/snapshot/clone_001_pos.ksh
	index 3abdff8c3bc7..1c8a3b2a6c20 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/snapshot/clone_001_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/snapshot/clone_001_pos.ksh
	@@ -1,171 +1,171 @@
	#! /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/snapshot/snapshot.cfg

	#
	# DESCRIPTION:
	# Create a snapshot from regular filesystem, volume,
	# or filesystem upon volume, Build a clone file system
	# from the snapshot and verify new files can be written.
	#
	# STRATEGY:
	# 1. Create snapshot use 3 combination:
	# - Regular filesystem
	# - Regular volume
	# - Filesystem upon volume
	# 2. Clone a new file system from the snapshot
	# 3. Verify the cloned file system is writable
	#

	verify_runnable "both"

	# Setup array, 4 elements as a group, refer to:
	# i+0: name of a snapshot
	# i+1: mountpoint of the snapshot
	# i+2: clone created from the snapshot
	# i+3: mountpoint of the clone

	set -A args "$SNAPFS" "$SNAPDIR" "$TESTPOOL/$TESTCLONE" "$TESTDIR.0" \
	"$SNAPFS1" "$SNAPDIR3" "$TESTPOOL/$TESTCLONE1" "" \
	"$SNAPFS2" "$SNAPDIR2" "$TESTPOOL1/$TESTCLONE2" "$TESTDIR.2"

	function setup_all
	{
	if is_freebsd; then
	# Pool creation on zvols is forbidden by default.
	# Save and the current setting.
	typeset _saved=$(get_tunable VOL_RECURSIVE)
	log_must set_tunable64 VOL_RECURSIVE 1
	fi
	create_pool $TESTPOOL1 ${ZVOL_DEVDIR}/$TESTPOOL/$TESTVOL
	if is_freebsd; then
	# Restore the previous setting.
	log_must set_tunable64 VOL_RECURSIVE $_saved
	fi
	log_must zfs create $TESTPOOL1/$TESTFS
	log_must zfs set mountpoint=$TESTDIR2 $TESTPOOL1/$TESTFS

	return 0
	}

	function cleanup_all
	{
	typeset -i i=0

	i=0
	while (( i < ${#args[*]} )); do
	snapexists ${args[i]} && \
	destroy_dataset "${args[i]}" "-Rf"

	[[ -d ${args[i+3]} ]] && \
	log_must rm -rf ${args[i+3]}

	[[ -d ${args[i+1]} ]] && \
	log_must rm -rf ${args[i+1]}

	(( i = i + 4 ))
	done

	- datasetexists $TESTPOOL1/$TESTFS && \
	- log_must zfs destroy -f $TESTPOOL1/$TESTFS
	+ datasetexists $TESTPOOL1/$TESTFS && \
	+ destroy_dataset $TESTPOOL1/$TESTFS -f

	destroy_pool $TESTPOOL1

	[[ -d $TESTDIR2 ]] && \
	log_must rm -rf $TESTDIR2

	return 0
	}

	log_assert "Verify a cloned file system is writable."

	log_onexit cleanup_all

	setup_all

	[[ -n $TESTDIR ]] && \
	log_must rm -rf $TESTDIR/* > /dev/null 2>&1

	typeset -i COUNT=10
	typeset -i i=0

	for mtpt in $TESTDIR $TESTDIR2 ; do
	log_note "Populate the $mtpt directory (prior to snapshot)"
	typeset -i j=1
	while [[ $j -le $COUNT ]]; do
	log_must file_write -o create -f $mtpt/before_file$j \
	-b $BLOCKSZ -c $NUM_WRITES -d $j

	(( j = j + 1 ))
	done
	done

	while (( i < ${#args[*]} )); do
	#
	# Take a snapshot of the test file system.
	#
	log_must zfs snapshot ${args[i]}

	#
	# Clone a new file system from the snapshot
	#
	log_must zfs clone ${args[i]} ${args[i+2]}
	if [[ -n ${args[i+3]} ]] ; then
	log_must zfs set mountpoint=${args[i+3]} ${args[i+2]}

	FILE_COUNT=`ls -Al ${args[i+3]} \| grep -v "total" \
	\| grep -v "\.zfs" \| wc -l`
	if [[ $FILE_COUNT -ne $COUNT ]]; then
	ls -Al ${args[i+3]}
	log_fail "AFTER: ${args[i+3]} contains $FILE_COUNT files(s)."
	fi

	log_note "Verify the ${args[i+3]} directory is writable"
	j=1
	while [[ $j -le $COUNT ]]; do
	log_must file_write -o create -f ${args[i+3]}/after_file$j \
	-b $BLOCKSZ -c $NUM_WRITES -d $j
	(( j = j + 1 ))
	done

	FILE_COUNT=`ls -Al ${args[i+3]}/after* \| grep -v "total" \| wc -l`
	if [[ $FILE_COUNT -ne $COUNT ]]; then
	ls -Al ${args[i+3]}
	log_fail "${args[i+3]} contains $FILE_COUNT after* files(s)."
	fi
	fi

	(( i = i + 4 ))
	done

	log_pass "The clone file system is writable."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/snapshot/snapshot_011_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/snapshot/snapshot_011_pos.ksh
	index 44e5943bcd2f..7e0a7f4ce1d8 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/snapshot/snapshot_011_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/snapshot/snapshot_011_pos.ksh
	@@ -1,113 +1,112 @@
	#! /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/snapshot/snapshot.cfg

	#
	# DESCRIPTION:
	# use 'snapshot -r' to create a snapshot tree, add some files to one child
	# filesystem, rollback the child filesystem snapshot, verify that the child
	# filesystem gets back to the status while taking the snapshot.
	#
	# STRATEGY:
	# 1. Add some files to a target child filesystem
	# 2. snapshot -r the parent filesystem
	# 3. Add some other files to the target child filesystem
	# 4. rollback the child filesystem snapshot
	# 5. verify that the child filesystem get back to the status while being
	# snapshot'd
	#

	verify_runnable "both"

	function cleanup
	{
	- snapexists $SNAPPOOL && \
	- log_must zfs destroy -r $SNAPPOOL
	+ snapexists $SNAPPOOL && destroy_dataset $SNAPPOOL -r

	[[ -e $TESTDIR ]] && \
	log_must rm -rf $TESTDIR/* > /dev/null 2>&1
	}

	log_assert "Verify that rollback to a snapshot created by snapshot -r succeeds."
	log_onexit cleanup

	[[ -n $TESTDIR ]] && \
	log_must rm -rf $TESTDIR/* > /dev/null 2>&1

	typeset -i COUNT=10

	log_note "Populate the $TESTDIR directory (prior to snapshot)"
	typeset -i i=0
	while (( i < COUNT )); do
	log_must file_write -o create -f $TESTDIR/before_file$i \
	-b $BLOCKSZ -c $NUM_WRITES -d $i

	(( i = i + 1 ))
	done

	log_must zfs snapshot -r $SNAPPOOL

	FILE_COUNT=`ls -Al $SNAPDIR \| grep -v "total" \| wc -l`
	if (( FILE_COUNT != COUNT )); then
	ls -Al $SNAPDIR
	log_fail "AFTER: $SNAPFS contains $FILE_COUNT files(s)."
	fi

	log_note "Populate the $TESTDIR directory (post snapshot)"
	typeset -i i=0
	while (( i < COUNT )); do
	log_must file_write -o create -f $TESTDIR/after_file$i \
	-b $BLOCKSZ -c $NUM_WRITES -d $i

	(( i = i + 1 ))
	done

	#
	# Now rollback to latest snapshot
	#
	log_must zfs rollback $SNAPFS

	FILE_COUNT=`ls -Al $TESTDIR/after* 2> /dev/null \| grep -v "total" \| wc -l`
	if (( FILE_COUNT != 0 )); then
	ls -Al $TESTDIR
	log_fail "$TESTDIR contains $FILE_COUNT after* files(s)."
	fi

	FILE_COUNT=`ls -Al $TESTDIR/before* 2> /dev/null \
	\| grep -v "total" \| wc -l`
	if (( FILE_COUNT != $COUNT )); then
	ls -Al $TESTDIR
	log_fail "$TESTDIR contains $FILE_COUNT before* files(s)."
	fi

	log_pass "Rollback with child snapshot works as expected."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/snapshot/snapshot_012_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/snapshot/snapshot_012_pos.ksh
	index c5717e452686..92db9b53a7b8 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/snapshot/snapshot_012_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/snapshot/snapshot_012_pos.ksh
	@@ -1,104 +1,103 @@
	#! /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
	. $STF_SUITE/tests/functional/snapshot/snapshot.cfg

	#
	# DESCRIPTION:
	# Verify 'snapshot -r' can create snapshot for promoted clone, and vice
	# versa, a clone filesystem from the snapshot created by 'snapshot -r'
	# can be correctly promoted.
	#
	# STRATEGY:
	# 1. Create a dataset tree
	# 2. snapshot a filesystem and clone the snapshot
	# 3. promote the clone
	# 4. snapshot -r the dataset tree
	# 5. verify that the snapshot of cloned filesystem is created correctly
	# 6. clone a snapshot from the snapshot tree
	# 7. promote the clone
	# 8. verify that the clone is promoted correctly.
	#

	verify_runnable "both"

	function cleanup
	{
	if datasetexists $clone1; then
	log_must zfs promote $ctrfs
	- log_must zfs destroy $clone1
	+ destroy_dataset $clone1
	fi

	- snapexists $snapctr && \
	- log_must zfs destroy -r $snapctr
	+ snapexists $snapctr && destroy_dataset $snapctr -r

	if snapexists $clone@$TESTSNAP1; then
	log_must zfs promote $ctrfs
	- log_must zfs destroy -rR $ctrfs@$TESTSNAP1
	+ destroy_dataset $ctrfs@$TESTSNAP1 -rR
	fi
	}

	log_assert "Verify that 'snapshot -r' can work with 'zfs promote'."
	log_onexit cleanup

	ctr=$TESTPOOL/$TESTCTR
	ctrfs=$ctr/$TESTFS1
	clone=$ctr/$TESTCLONE
	clone1=$ctr/$TESTCLONE1
	snappool=$SNAPPOOL
	snapfs=$SNAPFS
	snapctr=$ctr@$TESTSNAP
	snapctrclone=$clone@$TESTSNAP
	snapctrclone1=$clone1@$TESTSNAP
	snapctrfs=$SNAPCTR

	#preparation for testing
	log_must zfs snapshot $ctrfs@$TESTSNAP1
	log_must zfs clone $ctrfs@$TESTSNAP1 $clone
	log_must zfs promote $clone

	log_must zfs snapshot -r $snapctr

	! snapexists $snapctrclone && \
	log_fail "'snapshot -r' fails to create $snapctrclone for $ctr/$TESTCLONE."

	log_must zfs clone $snapctrfs $clone1
	log_must zfs promote $clone1

	#verify the origin value is correct.
	orig_value=$(get_prop origin $ctrfs)
	if ! snapexists $snapctrclone1 \|\| [[ "$orig_value" != "$snapctrclone1" ]]; then
	log_fail "'zfs promote' fails to promote $clone which is cloned from \
	$snapctrfs."
	fi

	log_pass "'snapshot -r' can work with 'zfs promote' as expected."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/snapshot/snapshot_013_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/snapshot/snapshot_013_pos.ksh
	index 31aedb224515..e02f6eb30042 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/snapshot/snapshot_013_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/snapshot/snapshot_013_pos.ksh
	@@ -1,99 +1,96 @@
	#! /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/snapshot/snapshot.cfg

	#
	# DESCRIPTION:
	# verify that the snapshots created by 'snapshot -r' can be used for
	# zfs send/recv
	#
	# STRATEGY:
	# 1. create a dataset tree and populate a filesystem
	# 2. snapshot -r the dataset tree
	# 3. select one snapshot used for zfs send/recv
	# 4. verify the data integrity after zfs send/recv
	#

	verify_runnable "both"

	function cleanup
	{
	- datasetexists $ctrfs && \
	- zfs destroy -r $ctrfs
	-
	- snapexists $snappool && \
	- log_must zfs destroy -r $snappool
	+ datasetexists $ctrfs && destroy_dataset $ctrfs -r
	+ snapexists $snappool && destroy_dataset $snappool -r

	[[ -e $TESTDIR ]] && \
	log_must rm -rf $TESTDIR/* > /dev/null 2>&1
	}

	log_assert "Verify snapshots from 'snapshot -r' can be used for zfs send/recv"
	log_onexit cleanup

	ctr=$TESTPOOL/$TESTCTR
	ctrfs=$ctr/$TESTFS
	snappool=$SNAPPOOL
	snapfs=$SNAPFS
	snapctr=$ctr@$TESTSNAP
	snapctrfs=$ctrfs@$TESTSNAP
	fsdir=/$ctrfs
	snapdir=$fsdir/.zfs/snapshot/$TESTSNAP

	[[ -n $TESTDIR ]] && \
	log_must rm -rf $TESTDIR/* > /dev/null 2>&1

	typeset -i COUNT=10

	log_note "Populate the $TESTDIR directory (prior to snapshot)"
	typeset -i i=0
	while (( i < COUNT )); do
	log_must file_write -o create -f $TESTDIR/file$i \
	-b $BLOCKSZ -c $NUM_WRITES -d $i

	(( i = i + 1 ))
	done

	log_must zfs snapshot -r $snappool

	zfs send $snapfs \| zfs receive $ctrfs >/dev/null 2>&1
	if ! datasetexists $ctrfs \|\| ! snapexists $snapctrfs; then
	log_fail "zfs send/receive fails with snapshot $snapfs."
	fi

	for dir in $fsdir $snapdir; do
	FILE_COUNT=`ls -Al $dir \| grep -v "total" \| wc -l`
	(( FILE_COUNT != COUNT )) && log_fail "Got $FILE_COUNT expected $COUNT"
	done

	log_pass "'zfs send/receive' works as expected with snapshots from 'snapshot -r'"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/snapshot/snapshot_014_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/snapshot/snapshot_014_pos.ksh
	index 3579fbebb4b8..d48d404b6d14 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/snapshot/snapshot_014_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/snapshot/snapshot_014_pos.ksh
	@@ -1,78 +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 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/snapshot/snapshot.cfg

	#
	# DESCRIPTION:
	# verify that creating/destroying snapshots do things clean
	#
	# STRATEGY:
	# 1. create a dataset and set a quota with 500m
	# 2. create file of size 400m on the dataset
	# 3. take a snapshot and destroy it
	# 4. then create file to use all spaces in the dataset
	# 5. verify removing the first file should succeed
	#

	verify_runnable "both"

	function cleanup
	{
	[[ -e $TESTDIR1 ]] && \
	log_must rm -rf $TESTDIR1/* > /dev/null 2>&1

	- snapexists $SNAPCTR && \
	- log_must zfs destroy $SNAPCTR
	+ snapexists $SNAPCTR && destroy_dataset $SNAPCTR

	datasetexists $TESTPOOL/$TESTCTR/$TESTFS1 && \
	log_must zfs set quota=none $TESTPOOL/$TESTCTR/$TESTFS1

	}

	log_assert "Verify creating/destroying snapshots do things clean"
	log_onexit cleanup

	log_must zfs set quota=$FSQUOTA $TESTPOOL/$TESTCTR/$TESTFS1
	log_must mkfile $FILESIZE $TESTDIR1/$TESTFILE

	log_must zfs snapshot $SNAPCTR
	log_must zfs destroy $SNAPCTR

	log_note "Make the quota of filesystem is reached"
	log_mustnot mkfile $FILESIZE1 $TESTDIR1/$TESTFILE1

	log_note "Verify removing the first file should succeed after the snapshot is \
	removed"
	log_must rm $TESTDIR1/$TESTFILE

	log_pass "Verify creating/destroying snapshots do things clean"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/snapshot/snapshot_015_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/snapshot/snapshot_015_pos.ksh
	index 1091bcb13ea7..5a4d2ccaf62e 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/snapshot/snapshot_015_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/snapshot/snapshot_015_pos.ksh
	@@ -1,121 +1,121 @@
	#!/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/snapshot/snapshot.cfg
	. $STF_SUITE/tests/functional/cli_root/zfs_rollback/zfs_rollback_common.kshlib

	#
	# DESCRIPTION:
	# Verify snapshot can be created or destroy via mkdir or rm
	# in .zfs/snapshot.
	#
	# STRATEGY:
	# 1. Verify make directories only successfully in .zfs/snapshot.
	# 2. Verify snapshot can be created and destroy via mkdir and remove
	# directories in .zfs/snapshot.
	# 3. Verify rollback to previous snapshot can succeed.
	# 4. Verify remove directory in snapdir can destroy snapshot.
	#

	verify_runnable "both"

	function cleanup
	{
	typeset -i i=0
	while ((i < snap_cnt)); do
	typeset snap=$fs@snap.$i
	- datasetexists $snap && log_must zfs destroy -f $snap
	+ datasetexists $snap && destroy_dataset $snap -f

	((i += 1))
	done
	}

	zfs 2>&1 \| grep "allow" > /dev/null
	(($? != 0)) && log_unsupported

	log_assert "Verify snapshot can be created via mkdir in .zfs/snapshot."
	log_onexit cleanup

	fs=$TESTPOOL/$TESTFS
	# Verify all the other directories are readonly.
	mntpnt=$(get_prop mountpoint $fs)
	snapdir=$mntpnt/.zfs
	set -A ro_dirs "$snapdir" "$snapdir/snap" "$snapdir/snapshot"
	for dir in ${ro_dirs[@]}; do
	if [[ -d $dir ]]; then
	log_mustnot rm -rf $dir
	log_mustnot touch $dir/testfile
	else
	log_mustnot mkdir $dir
	fi
	done

	# Verify snapshot can be created via mkdir in .zfs/snapshot
	typeset -i snap_cnt=5
	typeset -i cnt=0
	while ((cnt < snap_cnt)); do
	testfile=$mntpnt/testfile.$cnt
	log_must mkfile 1M $testfile
	log_must mkdir $snapdir/snapshot/snap.$cnt
	if ! datasetexists $fs@snap.$cnt ; then
	log_fail "ERROR: $fs@snap.$cnt should exists."
	fi

	((cnt += 1))
	done

	# Verify rollback to previous snapshot succeed.
	((cnt = RANDOM % snap_cnt))
	log_must zfs rollback -r $fs@snap.$cnt

	typeset -i i=0
	while ((i < snap_cnt)); do
	testfile=$mntpnt/testfile.$i
	if ((i <= cnt)); then
	if [[ ! -f $testfile ]]; then
	log_fail "ERROR: $testfile should exists."
	fi
	else
	if [[ -f $testfile ]]; then
	log_fail "ERROR: $testfile should not exists."
	fi
	fi

	((i += 1))
	done

	# Verify remove directory in snapdir can destroy snapshot.
	log_must rmdir $snapdir/snapshot/snap.$cnt
	log_mustnot datasetexists $fs@snap.$cnt

	log_pass "Verify snapshot can be created via mkdir in .zfs/snapshot passed."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/snapshot/snapshot_016_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/snapshot/snapshot_016_pos.ksh
	index b460c2b0c5dc..b66023cc85e6 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/snapshot/snapshot_016_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/snapshot/snapshot_016_pos.ksh
	@@ -1,103 +1,96 @@
	#!/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
	. $STF_SUITE/tests/functional/snapshot/snapshot.cfg

	#
	# DESCRIPTION:
	# Verify renamed snapshots via mv can be destroyed
	#
	# STRATEGY:
	# 1. Create snapshot
	# 2. Rename the snapshot via mv command
	# 2. Verify destroying the renamed snapshot via 'zfs destroy' succeeds
	#

	verify_runnable "both"

	function cleanup
	{
	- datasetexists $SNAPFS && \
	- log_must zfs destroy -Rf $SNAPFS
	- datasetexists $TESTPOOL/$TESTFS@snap_a && \
	- log_must zfs destroy -Rf $TESTPOOL/$TESTFS@snap_a
	- datasetexists $TESTPOOL/$TESTFS@snap_b && \
	- log_must zfs destroy -Rf $TESTPOOL/$TESTFS@snap_b
	- datasetexists $TESTPOOL/$TESTCLONE@snap_a && \
	- log_must zfs destroy -Rf $TESTPOOL/$TESTCLONE@snap_a
	-
	- datasetexists $TESTPOOL/$TESTCLONE && \
	- log_must zfs destroy $TESTPOOL/$TESTCLONE
	- datasetexists $TESTPOOL/$TESTFS && \
	- log_must zfs destroy $TESTPOOL/$TESTFS
	+ datasetexists $SNAPFS && destroy_dataset $SNAPFS -Rf
	+ datasetexists $TESTPOOL/$TESTFS@snap_a && destroy_dataset $TESTPOOL/$TESTFS@snap_a -Rf
	+ datasetexists $TESTPOOL/$TESTFS@snap_b && destroy_dataset $TESTPOOL/$TESTFS@snap_b -Rf
	+ datasetexists $TESTPOOL/$TESTCLONE@snap_a && destroy_dataset $TESTPOOL/$TESTCLONE@snap_a -Rf
	+ datasetexists $TESTPOOL/$TESTCLONE && destroy_dataset $TESTPOOL/$TESTCLONE
	+ datasetexists $TESTPOOL/$TESTFS && destroy_dataset $TESTPOOL/$TESTFS

	log_must zfs create $TESTPOOL/$TESTFS
	log_must zfs set mountpoint=$TESTDIR $TESTPOOL/$TESTFS
	}

	log_assert "Verify renamed snapshots via mv can be destroyed."
	log_onexit cleanup

	# scenario 1

	log_must zfs snapshot $SNAPFS
	log_must mv $TESTDIR/$SNAPROOT/$TESTSNAP $TESTDIR/$SNAPROOT/snap_a

	datasetexists $TESTPOOL/$TESTFS@snap_a \|\| \
	log_fail "rename snapshot via mv in .zfs/snapshot fails."
	log_must zfs destroy $TESTPOOL/$TESTFS@snap_a

	# scenario 2

	log_must zfs snapshot $SNAPFS
	log_must zfs clone $SNAPFS $TESTPOOL/$TESTCLONE
	log_must mv $TESTDIR/$SNAPROOT/$TESTSNAP $TESTDIR/$SNAPROOT/snap_b

	datasetexists $TESTPOOL/$TESTFS@snap_b \|\| \
	log_fail "rename snapshot via mv in .zfs/snapshot fails."
	log_must zfs promote $TESTPOOL/$TESTCLONE
	# promote back to $TESTPOOL/$TESTFS for scenario 3
	log_must zfs promote $TESTPOOL/$TESTFS
	log_must zfs destroy $TESTPOOL/$TESTCLONE
	log_must zfs destroy $TESTPOOL/$TESTFS@snap_b

	# scenario 3

	log_must zfs snapshot $SNAPFS
	log_must zfs clone $SNAPFS $TESTPOOL/$TESTCLONE
	log_must zfs rename $SNAPFS $TESTPOOL/$TESTFS@snap_a
	log_must zfs promote $TESTPOOL/$TESTCLONE
	log_must zfs destroy $TESTPOOL/$TESTFS
	log_must zfs destroy $TESTPOOL/$TESTCLONE@snap_a

	log_pass "Verify renamed snapshots via mv can be destroyed."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/snapshot/snapshot_017_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/snapshot/snapshot_017_pos.ksh
	index a21f8750d697..6e5b8973cf4f 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/snapshot/snapshot_017_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/snapshot/snapshot_017_pos.ksh
	@@ -1,202 +1,201 @@
	#!/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
	. $STF_SUITE/tests/functional/snapshot/snapshot.cfg

	#
	# DESCRIPTION:
	#
	# Directory structure of snapshots reflects filesystem structure.
	#
	# STRATEGY:
	#
	# This test makes sure that the directory structure of snapshots is
	# a proper reflection of the filesystem the snapshot was taken of.
	#
	# 1. Create a simple directory structure of files and directories
	# 2. Take a snapshot of the filesystem
	# 3. Modify original filesystem
	# 4. Walk down the snapshot directory structure verifying it
	# checking with both absolute and relative paths
	#

	verify_runnable "both"

	function cleanup
	{
	cd $SAVED_DIR

	- if datasetexists $TESTPOOL/$TESTFS ; then
	- log_must zfs destroy -Rf $TESTPOOL/$TESTFS
	- fi
	+ datasetexists $TESTPOOL/$TESTFS && \
	+ destroy_dataset $TESTPOOL/$TESTFS -Rf

	log_must zfs create $TESTPOOL/$TESTFS
	log_must zfs set mountpoint=$TESTDIR $TESTPOOL/$TESTFS
	}

	function verify_structure {

	# check absolute paths
	DIR=$PWD
	verify_file $DIR/file1
	verify_file $DIR/file2
	verify_file $DIR/dir1/file3
	verify_file $DIR/dir1/file4
	verify_file $DIR/dir1/dir2/file5
	verify_file $DIR/dir1/dir2/file6

	verify_no_file $DIR/file99

	# check relative paths
	verify_file ./file1
	verify_file ./file2
	verify_file ./dir1/file3
	verify_file ./dir1/file4
	verify_file ./dir1/dir2/file5
	verify_file ./dir1/dir2/file6

	cd dir1
	verify_file ../file1
	verify_file ../file2
	verify_file ./file3
	verify_file ./file4

	verify_no_file ../file99

	cd dir2
	verify_file ./file5
	verify_file ./file6
	verify_file ../file3
	verify_file ../file4
	verify_no_file ../file99

	verify_file ../../file1
	verify_file ../../file2
	verify_no_file ../../file99
	}

	function verify_file {
	if [ ! -e $1 ]
	then
	log_note "Working dir is $PWD"
	log_fail "File $1 does not exist!"
	fi
	}

	function verify_no_file {
	if [ -e $1 ]
	then
	log_note "Working dir is $PWD"
	log_fail "File $1 exists when it should not!"
	fi
	}

	function verify_dir {
	if [ ! -d $1 ]
	then
	log_note "Working dir is $PWD"
	log_fail "Directory $1 does not exist!"
	fi
	}

	log_assert "Directory structure of snapshots reflects filesystem structure."
	log_onexit cleanup

	SAVED_DIR=$PWD

	#
	# Create a directory structure with the following files
	#
	# ./file1
	# ./file2
	# ./dir1/file3
	# ./dir1/file4
	# ./dir1/dir2/file5
	# ./dir1/dir2/file6

	cd $TESTDIR
	mkfile 10m file1
	mkfile 20m file2
	mkdir dir1
	cd dir1
	mkfile 10m file3
	mkfile 20m file4
	mkdir dir2
	cd dir2
	mkfile 10m file5
	mkfile 20m file6

	# Now walk the directory structure verifying it
	cd $TESTDIR
	verify_structure

	# Take snapshots
	log_must zfs snapshot $TESTPOOL/$TESTFS@snap_a
	log_must zfs snapshot $TESTPOOL/$TESTFS@snap_b

	# Change the filesystem structure by renaming files in the original structure
	# The snapshot file structure should not change
	cd $TESTDIR
	log_must mv file2 file99
	cd dir1
	log_must mv file4 file99
	cd dir2
	log_must mv file6 file99

	# verify the top level snapshot directories
	verify_dir $TESTDIR/.zfs
	verify_dir $TESTDIR/.zfs/snapshot
	verify_dir $TESTDIR/.zfs/snapshot/snap_a
	verify_dir $TESTDIR/.zfs/snapshot/snap_b

	cd $TESTDIR/.zfs/snapshot/snap_a
	verify_structure

	cd $TESTDIR/.zfs/snapshot/snap_b
	verify_structure

	cd $TESTDIR/.zfs
	verify_dir snapshot
	cd $TESTDIR/.zfs/snapshot
	verify_dir snap_a
	verify_dir snap_b

	cd snap_a
	verify_dir ../snap_a
	verify_dir ../snap_b

	cd ..
	verify_dir snap_a
	verify_dir snap_b

	log_pass "Directory structure of snapshots reflects filesystem structure."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/snapused/snapused_001_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/snapused/snapused_001_pos.ksh
	index 302ba40c38a3..c1277f2b4e2f 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/snapused/snapused_001_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/snapused/snapused_001_pos.ksh
	@@ -1,91 +1,91 @@
	#!/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/snapused/snapused.kshlib

	#
	# DESCRIPTION:
	# Verify used is correct.
	#
	# STRATEGY:
	# 1. Create a filesystem.
	# 2. Set refreservation of the filesystem.
	# 3. Make file in the filesystem.
	# 4. Create sub filesystem and make file in it.
	# 5. Create volume under it.
	# 6. Snapshot it.
	# 7. Check used=usedbychildren+usedbydataset+
	# usedbyrefreservation+usedbysnapshots.
	#

	verify_runnable "both"

	function cleanup
	{
	- log_must zfs destroy -rR $USEDTEST
	+ datasetexists $USEDTEST && destroy_dataset $USEDTEST -rR
	}

	log_assert "Verify used is correct."
	log_onexit cleanup

	log_must zfs create $USEDTEST
	check_used $USEDTEST

	typeset -i i=0
	typeset -i r_size=0
	mntpnt=$(get_prop mountpoint $USEDTEST)
	while ((i < 5)); do
	((r_size=(i+1)*16))

	#usedbyrefreservation
	log_must zfs set refreservation="$r_size"M $USEDTEST

	#usedbydataset
	log_must mkfile 16M $mntpnt/file$i

	#usedbychildren
	log_must zfs create $USEDTEST/fs$i
	log_must mkfile 16M $mntpnt/fs$i/file$i

	if is_global_zone; then
	log_must zfs create -V 16M $USEDTEST/vol$i
	fi

	#usedbysnapshots
	log_must zfs snapshot -r $USEDTEST@snap$i

	check_used $USEDTEST

	((i = i + 1))
	done

	log_pass "Verify used is correct."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/snapused/snapused_002_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/snapused/snapused_002_pos.ksh
	index 96d2df6c6522..a41ca1d70f19 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/snapused/snapused_002_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/snapused/snapused_002_pos.ksh
	@@ -1,82 +1,82 @@
	#!/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/snapused/snapused.kshlib

	#
	# DESCRIPTION:
	# Verify usedbychildren is correct.
	#
	# STRATEGY:
	# 1. Create a filesystem.
	# 2. Create sub filesystem and make file in it.
	# 3. Set reservation of the sub filesystem.
	# 4. Create volume under it.
	# 5. Snapshot it.
	# 6. Check usedbychildren is correct.
	#

	verify_runnable "both"

	function cleanup
	{
	- log_must zfs destroy -rR $USEDTEST
	+ datasetexists $USEDTEST && destroy_dataset $USEDTEST -rR
	}

	log_assert "Verify usedbychildren is correct."
	log_onexit cleanup

	log_must zfs create $USEDTEST
	check_usedbychildren $USEDTEST

	typeset -i i=0
	typeset -i r_size=0
	mntpnt=$(get_prop mountpoint $USEDTEST)
	while ((i < 5)); do
	((r_size=(i+1)*16))

	log_must zfs create $USEDTEST/fs$i
	log_must zfs set reservation="$r_size"M $USEDTEST/fs$i
	log_must mkfile 48M $mntpnt/fs$i/file$i

	if is_global_zone; then
	log_must zfs create -V 32M $USEDTEST/vol$i
	fi

	log_must zfs snapshot -r $USEDTEST@snap$i

	check_usedbychildren $USEDTEST

	((i = i + 1))
	done

	log_pass "Verify usedbychildren is correct."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/snapused/snapused_003_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/snapused/snapused_003_pos.ksh
	index d4726ff40cbd..ff54cbaa1aec 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/snapused/snapused_003_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/snapused/snapused_003_pos.ksh
	@@ -1,82 +1,82 @@
	#!/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/snapused/snapused.kshlib

	#
	# DESCRIPTION:
	# Verify usedbydataset is correct.
	#
	# STRATEGY:
	# 1. Create a filesystem.
	# 2. Make file in the filesystem.
	# 3. Snapshot it.
	# 4. Clone it and make file in the cloned filesystem.
	# 5. Check usedbydataset is correct.
	#

	verify_runnable "both"

	function cleanup
	{
	- log_must zfs destroy -rR $USEDTEST
	+ datasetexists $USEDTEST && destroy_dataset $USEDTEST -rR
	}

	log_assert "Verify usedbydataset is correct."
	log_onexit cleanup

	log_must zfs create $USEDTEST
	check_usedbydataset $USEDTEST

	typeset -i i=0
	typeset -i r_size=0
	mntpnt=$(get_prop mountpoint $USEDTEST)
	while ((i < 5)); do
	((r_size=(i+1)*16))

	log_must mkfile 16M $mntpnt/file$i
	log_must mkfile "$r_size"M $mntpnt/file_var$i
	log_must zfs snapshot -r $USEDTEST@snap$i

	log_must zfs clone $USEDTEST@snap$i $USEDTEST/cln$i
	log_must zfs set is:cloned=yes $USEDTEST/cln$i

	mntpnt_cln=$(get_prop mountpoint $USEDTEST/cln$i)
	log_must mkfile 16M $mntpnt_cln/file_cln$i
	log_must mkfile "$r_size"M $mntpnt_cln/file_cln_var$i

	check_usedbydataset $USEDTEST

	((i = i + 1))
	done

	log_pass "Verify usedbydataset is correct."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/snapused/snapused_004_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/snapused/snapused_004_pos.ksh
	index 64ca3e2b3508..8fb8b6be5b47 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/snapused/snapused_004_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/snapused/snapused_004_pos.ksh
	@@ -1,95 +1,95 @@
	#!/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/snapused/snapused.kshlib

	#
	# DESCRIPTION:
	# Verify usedbyrefreservation is correct.
	#
	# STRATEGY:
	# 1. Create a filesystem.
	# 2. Set refreservation of the filesystem.
	# 3. Make file in the filesystem.
	# 4. Create sub filesystem and make file in it.
	# 5. Set refreservation of the sub filesystem.
	# 6. Create volume under it.
	# 7. Snapshot it.
	# 8. Clone it and set refreservation of the cloned filesystem.
	# 9. Makefile the cloned filesystem.
	# 10. Check usedbyrefreservation is correct.
	#

	verify_runnable "both"

	function cleanup
	{
	- log_must zfs destroy -rR $USEDTEST
	+ datasetexists $USEDTEST && destroy_dataset $USEDTEST -rR
	}

	log_assert "Verify usedbyrefreservation is correct."
	log_onexit cleanup

	log_must zfs create $USEDTEST
	check_usedbyrefreservation $USEDTEST

	typeset -i i=0
	typeset -i r_size=0
	mntpnt=$(get_prop mountpoint $USEDTEST)
	while ((i < 5)); do
	((r_size=(i+1)*16))
	log_must zfs set refreservation="$r_size"M $USEDTEST

	log_must mkfile 16M $mntpnt/file$i

	log_must zfs create $USEDTEST/fs$i
	log_must zfs set refreservation="$r_size"M $USEDTEST/fs$i
	log_must mkfile 16M $mntpnt/fs$i/file$i

	if is_global_zone; then
	log_must zfs create -V 16M $USEDTEST/vol$i
	fi

	log_must zfs snapshot -r $USEDTEST@snap$i

	log_must zfs clone $USEDTEST@snap$i $USEDTEST/cln$i

	mntpnt_cln=$(get_prop mountpoint $USEDTEST/cln$i)
	log_must zfs set refreservation="$r_size"M $USEDTEST/cln$i
	log_must mkfile 16M $mntpnt_cln/file_cln$i

	check_usedbyrefreservation $USEDTEST

	((i = i + 1))
	done

	log_pass "Verify usedbyrefreservation is correct."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/snapused/snapused_005_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/snapused/snapused_005_pos.ksh
	index ac5224caf6dc..9d21e1d23d87 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/snapused/snapused_005_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/snapused/snapused_005_pos.ksh
	@@ -1,73 +1,73 @@
	#!/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/snapused/snapused.kshlib

	#
	# DESCRIPTION:
	# Verify usedbysnapshots is correct.
	#
	# STRATEGY:
	# 1. Create a filesystem.
	# 2. Make file in the filesystem.
	# 3. Snapshot it.
	# 4. Check check_usedbysnapshots is correct.
	#

	verify_runnable "both"

	function cleanup
	{
	- log_must zfs destroy -rR $USEDTEST
	+ datasetexists $USEDTEST && destroy_dataset $USEDTEST -rR
	}

	log_assert "Verify usedbysnapshots is correct."
	log_onexit cleanup

	log_must zfs create $USEDTEST
	check_usedbysnapshots $USEDTEST

	typeset -i i=0
	typeset -i r_size=0
	mntpnt=$(get_prop mountpoint $USEDTEST)
	while ((i < 5)); do
	((r_size=(i+1)*16))

	log_must mkfile "$r_size"M $mntpnt/file$i

	log_must zfs snapshot $USEDTEST@snap$i
	check_usedbysnapshots $USEDTEST

	((i = i + 1))
	done

	log_pass "Verify usedbysnapshots is correct."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/userquota/groupspace_001_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/userquota/groupspace_001_pos.ksh
	index fb7a19057acf..762f561b834f 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/userquota/groupspace_001_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/userquota/groupspace_001_pos.ksh
	@@ -1,79 +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 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/userquota/userquota_common.kshlib

	#
	# DESCRIPTION:
	# Check the zfs groupspace with all parameters
	#
	#
	# STRATEGY:
	# 1. set zfs groupquota to a fs
	# 2. write some data to the fs with specified user and group
	# 3. use zfs groupspace with all possible parameters to check the result
	#

	function cleanup
	{
	- if datasetexists $snap_fs; then
	- log_must zfs destroy $snap_fs
	- fi
	+ datasetexists $snap_fs && destroy_dataset $snap_fs

	log_must cleanup_quota
	}

	log_onexit cleanup

	log_assert "Check the zfs groupspace with all possible parameters"

	set -A params -- "-n" "-H" "-p" "-o type,name,used,quota" \
	"-o name,used,quota" "-o used,quota" "-o used" "-o quota" "-s type" \
	"-s name" "-s used" "-s quota" "-S type" "-S name" "-S used" "-S quota" \
	"-t posixuser" "-t posixgroup" "-t all" "-i" "-t smbuser" "-t smbgroup"

	typeset snap_fs=$QFS@snap

	log_must zfs set groupquota@$QGROUP=500m $QFS
	mkmount_writable $QFS
	log_must user_run $QUSER1 mkfile 50m $QFILE

	sync

	log_must zfs snapshot $snap_fs

	for param in "${params[@]}"; do
	log_must eval "zfs groupspace $param $QFS >/dev/null 2>&1"
	log_must eval "zfs groupspace $param $snap_fs >/dev/null 2>&1"
	done

	log_pass "Check the zfs groupspace with all possible parameters"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/userquota/groupspace_002_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/userquota/groupspace_002_pos.ksh
	index 20d0f7319df1..27feafa2b6a2 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/userquota/groupspace_002_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/userquota/groupspace_002_pos.ksh
	@@ -1,79 +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 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/userquota/userquota_common.kshlib

	#
	# DESCRIPTION:
	# Check the user used and groupspace size in zfs groupspace
	#
	#
	# STRATEGY:
	# 1. set zfs groupquota to a fs
	# 2. write some data to the fs with specified user and size
	# 3. use zfs groupspace to check the used size and quota size
	#

	function cleanup
	{
	- if datasetexists $snapfs; then
	- log_must zfs destroy $snapfs
	- fi
	+ datasetexists $snapfs && destroy_dataset $snapfs
	log_must cleanup_quota
	}

	log_onexit cleanup

	log_assert "Check the zfs groupspace used and quota"

	log_must zfs set groupquota@$QGROUP=500m $QFS
	mkmount_writable $QFS
	log_must user_run $QUSER1 mkfile 100m $QFILE

	sync

	typeset snapfs=$QFS@snap

	log_must zfs snapshot $snapfs

	log_must eval "zfs groupspace $QFS >/dev/null 2>&1"
	log_must eval "zfs groupspace $snapfs >/dev/null 2>&1"

	for fs in "$QFS" "$snapfs"; do
	log_note "check the quota size in zfs groupspace $fs"
	log_must eval "zfs groupspace $fs \| grep $QGROUP \| grep 500M"

	log_note "check the user used size in zfs groupspace $fs"
	log_must eval "zfs groupspace $fs \| grep $QGROUP \| grep 100M"
	done

	log_pass "Check the zfs groupspace used and quota pass as expect"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/userquota/groupspace_003_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/userquota/groupspace_003_pos.ksh
	index 56b7af031550..37fd389377ec 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/userquota/groupspace_003_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/userquota/groupspace_003_pos.ksh
	@@ -1,109 +1,107 @@
	#!/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 by Delphix. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/include/math.shlib
	. $STF_SUITE/tests/functional/userquota/userquota_common.kshlib

	#
	# DESCRIPTION:
	# Check the user used and groupspace object counts in zfs groupspace
	#
	#
	# STRATEGY:
	# 1. set zfs groupquota to a fs
	# 2. create objects for different users in the same group
	# 3. use zfs groupspace to check the object count
	#

	function cleanup
	{
	- if datasetexists $snapfs; then
	- log_must zfs destroy $snapfs
	- fi
	+ datasetexists $snapfs && destroy_dataset $snapfs

	log_must rm -f ${QFILE}_*
	log_must cleanup_quota
	}

	function group_object_count
	{
	typeset fs=$1
	typeset group=$2
	typeset -i groupspacecnt=$(zfs groupspace -oname,objused $fs \|
	awk /$group/'{print $2}')
	typeset -i zfsgetcnt=$(zfs get -H -ovalue groupobjused@$group $fs)

	# 'zfs groupspace' and 'zfs get groupobjused@' should be equal
	verify_eq "$groupspacecnt" "$zfsgetcnt" "groupobjused@$group"

	echo $groupspacecnt
	}

	log_onexit cleanup

	log_assert "Check the zfs groupspace object used"

	mkmount_writable $QFS
	log_must zfs set xattr=sa $QFS

	((user1_cnt = RANDOM % 100 + 1))
	((user2_cnt = RANDOM % 100 + 1))
	log_must user_run $QUSER1 mkfiles ${QFILE}_1 $user1_cnt
	log_must user_run $QUSER2 mkfiles ${QFILE}_2 $user2_cnt
	((grp_cnt = user1_cnt + user2_cnt))
	sync_pool

	typeset snapfs=$QFS@snap

	log_must zfs snapshot $snapfs

	log_must eval "zfs groupspace $QFS >/dev/null 2>&1"
	log_must eval "zfs groupspace $snapfs >/dev/null 2>&1"

	for fs in "$QFS" "$snapfs"; do
	log_note "check the object count in zfs groupspace $fs"
	[[ $(group_object_count $fs $QGROUP) -eq $grp_cnt ]] \|\|
	log_fail "expected $grp_cnt"
	done

	log_note "file removal"
	log_must rm ${QFILE}_*
	sync_pool

	[[ $(group_object_count $QFS $QGROUP) -eq 0 ]] \|\|
	log_fail "expected 0 files for $QGROUP"

	[[ $(group_object_count $snapfs $QGROUP) -eq $grp_cnt ]] \|\|
	log_fail "expected $grp_cnt files for $QGROUP"

	cleanup
	log_pass "Check the zfs groupspace object used pass as expect"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/userquota/userquota_005_neg.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/userquota/userquota_005_neg.ksh
	index 5684b05b7e4b..b8e956164f73 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/userquota/userquota_005_neg.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/userquota/userquota_005_neg.ksh
	@@ -1,94 +1,92 @@
	#!/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/userquota/userquota_common.kshlib

	#
	# DESCRIPTION:
	# Check the invalid parameter of zfs set user\|group quota
	#
	#
	# STRATEGY:
	# 1. check the invalid zfs set user\|group quota to fs
	# 1. check the valid zfs set user\|group quota to snapshots
	#

	function cleanup
	{
	- if datasetexists $snap_fs; then
	- log_must zfs destroy $snap_fs
	- fi
	+ datasetexists $snap_fs && destroy_dataset $snap_fs

	log_must cleanup_quota
	}

	log_onexit cleanup

	log_assert "Check the invalid parameter of zfs set user\|group quota"
	typeset snap_fs=$QFS@snap

	log_must zfs snapshot $snap_fs

	set -A no_users "mms1234" "ss@#" "root-122"
	for user in "${no_users[@]}"; do
	log_mustnot id $user
	log_mustnot zfs set userquota@$user=100m $QFS
	done

	log_note "can set all numeric id even if that id does not exist"
	log_must zfs set userquota@12345678=100m $QFS
	log_mustnot zfs set userquota@12345678=100m $snap_fs

	set -A sizes "100mfsd" "m0.12m" "GGM" "-1234-m" "123m-m"

	for size in "${sizes[@]}"; do
	log_note "can not set user quota with invalid size parameter"
	log_mustnot zfs set userquota@root=$size $QFS
	done

	log_note "can not set user quota to snapshot $snap_fs"
	log_mustnot zfs set userquota@root=100m $snap_fs


	set -A no_groups "aidsf@dfsd@" "123223-dsfds#sdfsd" "mss_#ss" "@@@@"
	for group in "${no_groups[@]}"; do
	log_mustnot eval "grep $group /etc/group"
	log_mustnot zfs set groupquota@$group=100m $QFS
	done

	log_note "can not set group quota with invalid size parameter"
	log_mustnot zfs set groupquota@root=100msfsd $QFS

	log_note "can not set group quota to snapshot $snap_fs"
	log_mustnot zfs set groupquota@root=100m $snap_fs

	log_pass "Check the invalid parameter of zfs set user\|group quota pas as expect"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/userquota/userquota_006_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/userquota/userquota_006_pos.ksh
	index 7848a924bde8..1c2509c83705 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/userquota/userquota_006_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/userquota/userquota_006_pos.ksh
	@@ -1,79 +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 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/userquota/userquota_common.kshlib

	#
	# DESCRIPTION:
	# Check the invalid parameter of zfs get user\|group quota
	#
	#
	# STRATEGY:
	# 1. check the invalid zfs get user\|group quota to fs
	# 2. check the valid zfs get user\|group quota to snapshots
	#

	function cleanup
	{
	- if datasetexists $snap_fs; then
	- log_must zfs destroy $snap_fs
	- fi
	+ datasetexists $snap_fs && destroy_dataset $snap_fs

	log_must cleanup_quota
	}

	log_onexit cleanup

	log_assert "Check the invalid parameter of zfs get user\|group quota"
	typeset snap_fs=$QFS@snap

	log_must zfs snapshot $snap_fs

	set -A no_users "mms1234" "ss@#" "root-122" "1234"
	for user in "${no_users[@]}"; do
	log_mustnot eval "id $user >/dev/null 2>&1"
	log_must eval "zfs get userquota@$user $QFS >/dev/null 2>&1"
	log_must eval "zfs get userquota@$user $snap_fs >/dev/null 2>&1"
	done

	set -A no_groups "aidsf@dfsd@" "123223-dsfds#sdfsd" "mss_#ss" "1234"
	for group in "${no_groups[@]}"; do
	if is_freebsd; then
	log_mustnot eval "pw groupdel -n $group >/dev/null 2>&1"
	else
	log_mustnot eval "groupdel $group >/dev/null 2>&1"
	fi
	log_must eval "zfs get groupquota@$group $QFS >/dev/null 2>&1"
	log_must eval "zfs get groupquota@$group $snap_fs >/dev/null 2>&1"
	done

	log_pass "Check the invalid parameter of zfs get user\|group quota pass as expect"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/userquota/userquota_009_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/userquota/userquota_009_pos.ksh
	index 1c0fdde3fa46..b6f2727806c4 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/userquota/userquota_009_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/userquota/userquota_009_pos.ksh
	@@ -1,92 +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 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/userquota/userquota_common.kshlib

	#
	# DESCRIPTION:
	# Check user\|group quota to snapshot that:
	# 1) can not set user\|group quota to snapshot directly
	# 2) snapshot can inherit the parent fs's user\|groupquota
	# 3) the user\|group quota will not change even the parent fs's quota changed.
	#
	#
	# STRATEGY:
	# 1. create a snapshot of a fs
	# 2. set the user\|group quota to snapshot and expect fail
	# 3. set user\|group quota to fs and check the snapshot
	# 4. re-set user\|group quota to fs and check the snapshot's value
	#

	function cleanup
	{
	- if datasetexists $snap_fs; then
	- log_must zfs destroy $snap_fs
	- fi
	+ datasetexists $snap_fs && destroy_dataset $snap_fs

	log_must cleanup_quota
	}

	log_onexit cleanup

	log_assert "Check the snapshot's user\|group quota"
	typeset snap_fs=$QFS@snap


	log_must zfs set userquota@$QUSER1=$UQUOTA_SIZE $QFS
	log_must check_quota "userquota@$QUSER1" $QFS "$UQUOTA_SIZE"

	log_must zfs set groupquota@$QGROUP=$GQUOTA_SIZE $QFS
	log_must check_quota "groupquota@$QGROUP" $QFS "$GQUOTA_SIZE"

	log_must zfs snapshot $snap_fs

	log_note "check the snapshot $snap_fs user\|group quota"
	log_must check_quota "userquota@$QUSER1" $snap_fs "$UQUOTA_SIZE"
	log_must check_quota "groupquota@$QGROUP" $snap_fs "$GQUOTA_SIZE"

	log_note "set userquota and groupquota to $snap_fs which will fail"
	log_mustnot zfs set userquota@$QUSER1=$SNAP_QUOTA $snap_fs
	log_mustnot zfs set groupquota@$QGROUP=$SNAP_QUOTA $snap_fs

	log_note "change the parent's userquota and groupquota"
	log_must zfs set userquota@$QUSER1=$TEST_QUOTA $QFS
	log_must zfs set groupquota@$QGROUP=$TEST_QUOTA $QFS

	log_must check_quota "userquota@$QUSER1" $QFS $TEST_QUOTA
	log_must check_quota "groupquota@$QGROUP" $QFS $TEST_QUOTA

	log_note "check the snapshot $snap_fs userquota and groupquota"
	log_must check_quota "userquota@$QUSER1" $snap_fs "$UQUOTA_SIZE"
	log_must check_quota "groupquota@$QGROUP" $snap_fs "$GQUOTA_SIZE"

	log_pass "Check the snapshot's user\|group quota pass as expect"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/userquota/userquota_011_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/userquota/userquota_011_pos.ksh
	index 93020ae8ded6..8917b3be2865 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/userquota/userquota_011_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/userquota/userquota_011_pos.ksh
	@@ -1,127 +1,125 @@
	#!/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/userquota/userquota_common.kshlib

	#
	# DESCRIPTION:
	# the userquota and groupquota will not change during zfs actions, such as
	# snapshot,clone,rename,upgrade,send,receive.
	#
	#
	# STRATEGY:
	# 1. Create a pool, and create fs with preset user,group quota
	# 2. Check set user\|group quota via zfs snapshot\|clone\|list -o
	# 3. Check the user\|group quota can not change during zfs rename\|upgrade\|promote
	# 4. Check the user\|group quota can not change during zfs clone
	# 5. Check the user\|group quota can not change during zfs send/receive
	#

	function cleanup
	{
	for ds in $TESTPOOL/fs $TESTPOOL/fs-rename $TESTPOOL/fs-clone; do
	- if datasetexists $ds; then
	- log_must zfs destroy -rRf $ds
	- fi
	+ datasetexists $ds && destroy_dataset $ds -rRf
	done
	}

	log_onexit cleanup

	log_assert \
	"the userquota and groupquota can't change during zfs actions"

	cleanup

	log_must zfs create -o userquota@$QUSER1=$UQUOTA_SIZE \
	-o groupquota@$QGROUP=$GQUOTA_SIZE $TESTPOOL/fs

	log_must zfs snapshot $TESTPOOL/fs@snap
	log_must eval "zfs list -r -o userquota@$QUSER1,groupquota@$QGROUP \
	$TESTPOOL >/dev/null 2>&1"

	log_must check_quota "userquota@$QUSER1" $TESTPOOL/fs@snap "$UQUOTA_SIZE"
	log_must check_quota "groupquota@$QGROUP" $TESTPOOL/fs@snap "$GQUOTA_SIZE"


	log_note "clone fs gets its parent's userquota/groupquota initially"
	log_must zfs clone -o userquota@$QUSER1=$UQUOTA_SIZE \
	-o groupquota@$QGROUP=$GQUOTA_SIZE \
	$TESTPOOL/fs@snap $TESTPOOL/fs-clone

	log_must eval "zfs list -r -o userquota@$QUSER1,groupquota@$QGROUP \
	$TESTPOOL >/dev/null 2>&1"

	log_must check_quota "userquota@$QUSER1" $TESTPOOL/fs-clone "$UQUOTA_SIZE"
	log_must check_quota "groupquota@$QGROUP" $TESTPOOL/fs-clone "$GQUOTA_SIZE"

	log_must eval "zfs list -o userquota@$QUSER1,groupquota@$QGROUP \
	$TESTPOOL/fs-clone >/dev/null 2>&1"

	log_note "zfs promote can not change the previously set user\|group quota"
	log_must zfs promote $TESTPOOL/fs-clone

	log_must eval "zfs list -r -o userquota@$QUSER1,groupquota@$QGROUP \
	$TESTPOOL >/dev/null 2>&1"

	log_must check_quota "userquota@$QUSER1" $TESTPOOL/fs-clone "$UQUOTA_SIZE"
	log_must check_quota "groupquota@$QGROUP" $TESTPOOL/fs-clone "$GQUOTA_SIZE"

	log_note "zfs send receive can not change the previously set user\|group quota"
	log_must zfs send $TESTPOOL/fs-clone@snap \| zfs receive $TESTPOOL/fs-rev

	log_must eval "zfs list -r -o userquota@$QUSER1,groupquota@$QGROUP \
	$TESTPOOL >/dev/null 2>&1"

	log_must check_quota "userquota@$QUSER1" $TESTPOOL/fs-rev "$UQUOTA_SIZE"
	log_must check_quota "groupquota@$QGROUP" $TESTPOOL/fs-rev "$GQUOTA_SIZE"

	log_note "zfs rename can not change the previously set user\|group quota"
	log_must zfs rename $TESTPOOL/fs-rev $TESTPOOL/fs-rename

	log_must eval "zfs list -r -o userquota@$QUSER1,groupquota@$QGROUP \
	$TESTPOOL >/dev/null 2>&1"

	log_must check_quota "userquota@$QUSER1" $TESTPOOL/fs-rename "$UQUOTA_SIZE"
	log_must check_quota "groupquota@$QGROUP" $TESTPOOL/fs-rename "$GQUOTA_SIZE"

	log_note "zfs upgrade can not change the previously set user\|group quota"
	log_must zfs upgrade $TESTPOOL/fs-rename

	log_must eval "zfs list -r -o userquota@$QUSER1,groupquota@$QGROUP \
	$TESTPOOL >/dev/null 2>&1"

	log_must check_quota "userquota@$QUSER1" $TESTPOOL/fs-rename "$UQUOTA_SIZE"
	log_must check_quota "groupquota@$QGROUP" $TESTPOOL/fs-rename "$GQUOTA_SIZE"

	log_pass \
	"the userquota and groupquota can't change during zfs actions"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/userquota/userquota_012_neg.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/userquota/userquota_012_neg.ksh
	index b553f91d40da..12e023134d81 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/userquota/userquota_012_neg.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/userquota/userquota_012_neg.ksh
	@@ -1,66 +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 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/userquota/userquota_common.kshlib

	#
	# DESCRIPTION:
	# userquota and groupquota can not be set against snapshot
	#
	#
	# STRATEGY:
	# 1. Set userquota on snap and check the zfs get
	# 2. Set groupquota on snap and check the zfs get
	#

	function cleanup
	{
	cleanup_quota

	- if datasetexists $snap_fs; then
	- log_must zfs destroy $snap_fs
	- fi
	+ datasetexists $snap_fs && destroy_dataset $snap_fs
	}

	log_onexit cleanup

	typeset snap_fs=$QFS@snap
	log_assert "Check set userquota and groupquota on snapshot"

	log_note "Check can not set user\|group quota on snapshot"
	log_must zfs snapshot $snap_fs

	log_mustnot zfs set userquota@$QUSER1=$UQUOTA_SIZE $snap_fs

	log_mustnot zfs set groupquota@$QGROUP=$GQUOTA_SIZE $snap_fs

	log_pass "Check set userquota and groupquota on snapshot"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/userquota/userspace_001_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/userquota/userspace_001_pos.ksh
	index ef05338af41d..9b8919344582 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/userquota/userspace_001_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/userquota/userspace_001_pos.ksh
	@@ -1,78 +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 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/userquota/userquota_common.kshlib

	#
	# DESCRIPTION:
	# Check the zfs userspace with all parameters
	#
	#
	# STRATEGY:
	# 1. set zfs userspace to a fs
	# 2. write some data to the fs with specified user
	# 3. use zfs userspace with all possible parameters to check the result
	#

	function cleanup
	{
	- if datasetexists $snap_fs; then
	- log_must zfs destroy $snap_fs
	- fi
	+ datasetexists $snap_fs && destroy_dataset $snap_fs

	log_must cleanup_quota
	}

	log_onexit cleanup

	log_assert "Check the zfs userspace with all possible parameters"

	set -A params -- "-n" "-H" "-p" "-o type,name,used,quota" \
	"-o name,used,quota" "-o used,quota" "-o used" "-o quota" "-s type" \
	"-s name" "-s used" "-s quota" "-S type" "-S name" "-S used" "-S quota" \
	"-t posixuser" "-t posixgroup" "-t all" "-i" "-tsmbuser" "-t smbgroup"

	typeset snap_fs=$QFS@snap

	log_must zfs set userquota@$QUSER1=100m $QFS
	mkmount_writable $QFS
	log_must user_run $QUSER1 mkfile 50m $QFILE
	sync

	log_must zfs snapshot $snap_fs

	for param in "${params[@]}"; do
	log_must eval "zfs userspace $param $QFS >/dev/null 2>&1"
	log_must eval "zfs userspace $param $snap_fs >/dev/null 2>&1"
	done

	log_pass "zfs userspace with all possible parameters pass as expect"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/userquota/userspace_002_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/userquota/userspace_002_pos.ksh
	index 8161cc152037..94593ed21ae1 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/userquota/userspace_002_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/userquota/userspace_002_pos.ksh
	@@ -1,81 +1,79 @@
	#!/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/userquota/userquota_common.kshlib

	#
	# DESCRIPTION:
	# Check the user used size and quota in zfs userspace
	#
	#
	# STRATEGY:
	# 1. set zfs userquota to a fs
	# 2. write some data to the fs with specified user and size
	# 3. use zfs userspace to check the used size and quota size
	#

	function cleanup
	{
	- if datasetexists $snapfs; then
	- log_must zfs destroy $snapfs
	- fi
	+ datasetexists $snapfs && destroy_dataset $snapfs

	log_must cleanup_quota
	}

	log_onexit cleanup

	log_assert "Check the zfs userspace used and quota"

	log_must zfs set userquota@$QUSER1=100m $QFS

	mkmount_writable $QFS

	log_must user_run $QUSER1 mkfile 50m $QFILE
	sync

	typeset snapfs=$QFS@snap

	log_must zfs snapshot $snapfs

	log_must eval "zfs userspace $QFS >/dev/null 2>&1"
	log_must eval "zfs userspace $snapfs >/dev/null 2>&1"

	for fs in "$QFS" "$snapfs"; do
	log_note "check the quota size in zfs userspace $fs"
	log_must eval "zfs userspace $fs \| grep $QUSER1 \| grep 100M"

	log_note "check the user used size in zfs userspace $fs"
	log_must eval "zfs userspace $fs \| grep $QUSER1 \| grep 50\\.\*M"
	done

	log_pass "Check the zfs userspace used and quota"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/userquota/userspace_003_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/userquota/userspace_003_pos.ksh
	index 96c3b1930c40..70ef78e7ddbb 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/userquota/userspace_003_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/userquota/userspace_003_pos.ksh
	@@ -1,122 +1,120 @@
	#!/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 Jinshan Xiong. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/include/math.shlib
	. $STF_SUITE/tests/functional/userquota/userquota_common.kshlib

	#
	# DESCRIPTION:
	# Check the user used object accounting in zfs userspace
	#
	#
	# STRATEGY:
	# 1. create a bunch of files by specific users
	# 2. use zfs userspace to check the used objects
	# 3. change the owner of test files and verify object count
	# 4. delete files and verify object count
	#

	function cleanup
	{
	- if datasetexists $snapfs; then
	- log_must zfs destroy $snapfs
	- fi
	+ datasetexists $snapfs && destroy_dataset $snapfs

	log_must rm -f ${QFILE}_*
	log_must cleanup_quota
	}

	function user_object_count
	{
	typeset fs=$1
	typeset user=$2
	typeset -i userspacecnt=$(zfs userspace -oname,objused $fs \|
	awk /$user/'{print $2}')
	typeset -i zfsgetcnt=$(zfs get -H -ovalue userobjused@$user $fs)

	# 'zfs userspace' and 'zfs get userobjused@' should be equal
	verify_eq "$userspacecnt" "$zfsgetcnt" "userobjused@$user"

	echo $userspacecnt
	}

	log_onexit cleanup

	log_assert "Check the zfs userspace object used"

	mkmount_writable $QFS
	log_must zfs set xattr=sa $QFS

	((user1_cnt = RANDOM % 100 + 1))
	((user2_cnt = RANDOM % 100 + 1))

	log_must user_run $QUSER1 mkfiles ${QFILE}_1 $user1_cnt
	log_must user_run $QUSER2 mkfiles ${QFILE}_2 $user2_cnt
	sync_pool

	typeset snapfs=$QFS@snap

	log_must zfs snapshot $snapfs

	log_must eval "zfs userspace $QFS >/dev/null 2>&1"
	log_must eval "zfs userspace $snapfs >/dev/null 2>&1"

	for fs in "$QFS" "$snapfs"; do
	log_note "check the user used objects in zfs userspace $fs"
	[[ $(user_object_count $fs $QUSER1) -eq $user1_cnt ]] \|\|
	log_fail "expected $user1_cnt"
	[[ $(user_object_count $fs $QUSER2) -eq $user2_cnt ]] \|\|
	log_fail "expected $user2_cnt"
	done

	log_note "change the owner of files"
	log_must chown $QUSER2 ${QFILE}_1*
	sync_pool

	[[ $(user_object_count $QFS $QUSER1) -eq 0 ]] \|\|
	log_fail "expected 0 files for $QUSER1"

	[[ $(user_object_count $snapfs $QUSER1) -eq $user1_cnt ]] \|\|
	log_fail "expected $user_cnt files for $QUSER1 in snapfs"

	[[ $(user_object_count $QFS $QUSER2) -eq $((user1_cnt+user2_cnt)) ]] \|\|
	log_fail "expected $((user1_cnt+user2_cnt)) files for $QUSER2"

	log_note "file removal"
	log_must rm ${QFILE}_*
	sync_pool

	[[ $(user_object_count $QFS $QUSER2) -eq 0 ]] \|\|
	log_fail "expected 0 files for $QUSER2"

	cleanup
	log_pass "Check the zfs userspace object used"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/zvol/zvol_cli/zvol_cli_002_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/zvol/zvol_cli/zvol_cli_002_pos.ksh
	index e5b69239f566..7b8749751b05 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/zvol/zvol_cli/zvol_cli_002_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/zvol/zvol_cli/zvol_cli_002_pos.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

	#
	# DESCRIPTION:
	# Creating a volume with a 50 letter name should work.
	#
	# STRATEGY:
	# 1. Using a very long name, create a zvol
	# 2. Verify volume exists
	#

	verify_runnable "global"

	function cleanup
	{
	datasetexists $TESTPOOL/$LONGVOLNAME && \
	- zfs destroy $TESTPOOL/$LONGVOLNAME
	+ destroy_dataset $TESTPOOL/$LONGVOLNAME
	}

	log_onexit cleanup

	log_assert "Creating a volume a 50 letter name should work."

	LONGVOLNAME="volumename50charslong_0123456789012345678901234567"

	log_must zfs create -V $VOLSIZE $TESTPOOL/$LONGVOLNAME

	datasetexists $TESTPOOL/$LONGVOLNAME \|\| \
	log_fail "Couldn't find long volume name"

	log_pass "Created a 50-letter zvol volume name"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/zvol/zvol_common.shlib b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/zvol/zvol_common.shlib
	index 342700228764..4f74c9b92613 100644
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/zvol/zvol_common.shlib
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/zvol/zvol_common.shlib
	@@ -1,134 +1,133 @@
	#
	# 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/zvol/zvol.cfg

	#
	# Create a simple zvol volume
	#
	# Where disk_device: is the name of the disk to be used
	# volume_size: is the size of the volume, e.g. 2G
	# block_size: is the block size of the volume
	#
	function default_zvol_setup # disk_device volume_size block_size
	{
	typeset disk=$1
	typeset size=$2
	typeset blocksize=$3
	typeset savedumpdev
	typeset -i output
	typeset create_args

	create_pool $TESTPOOL "$disk"

	if [ -n "$blocksize" ]; then
	create_args="-b $blocksize"
	fi

	log_must zfs create $create_args -V $size $TESTPOOL/$TESTVOL
	block_device_wait
	}

	#
	# Destroy the default zvol which was setup using
	# default_zvol_setup().
	#
	function default_zvol_cleanup
	{
	- if datasetexists $TESTPOOL/$TESTVOL ; then
	- log_must zfs destroy $TESTPOOL/$TESTVOL
	- fi
	+ datasetexists $TESTPOOL/$TESTVOL && \
	+ destroy_dataset $TESTPOOL/$TESTVOL

	destroy_pool $TESTPOOL
	}

	function get_dumpdevice
	{
	typeset ret=$(dumpadm \| grep "Dump device:" \| awk '{print $3}')
	echo $ret
	}

	function set_dumpsize
	{
	typeset volume=$1

	if [[ -z $volume ]] ; then
	log_note "No volume specified."
	return 1
	fi

	log_must zfs set volsize=64m $volume

	output=$(dumpadm -d /dev/zvol/dsk/$volume 2>&1 \| \
	tail -1 \| awk '{print $3}')

	if [[ -n $output ]]; then
	(( output = output / 1024 / 1024 ))
	(( output = output + output / 5 ))
	log_must zfs set volsize=${output}m $volume
	fi

	return 0
	}

	function safe_dumpadm
	{
	typeset device=$1

	if [[ -z $device \|\| $device == "none" ]] ; then
	log_note "No dump device volume specified."
	return 1
	fi
	if [[ $device == "${ZVOL_DEVDIR}/"* ]] ; then
	typeset volume=${device#${ZVOL_DEVDIR}/}
	set_dumpsize $volume
	log_must dumpadm -d $device
	else
	log_must swapadd
	if ! is_swap_inuse $device ; then
	log_must swap -a $device
	fi
	log_must dumpadm -d swap
	fi
	}

	function is_zvol_dumpified
	{
	typeset volume=$1

	if [[ -z $volume ]] ; then
	log_note "No volume specified."
	return 1
	fi

	zdb -dddd $volume 2 \| grep "dumpsize" > /dev/null 2>&1
	return $?
	}
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/zvol/zvol_misc/zvol_misc_002_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/zvol/zvol_misc/zvol_misc_002_pos.ksh
	index 72446ee986fe..2ecb00da92e1 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/zvol/zvol_misc/zvol_misc_002_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/zvol/zvol_misc/zvol_misc_002_pos.ksh
	@@ -1,117 +1,117 @@
	#!/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.
	# Copyright 2016 Nexenta Systems, Inc.
	#

	. $STF_SUITE/include/libtest.shlib

	#
	# DESCRIPTION:
	# Verify that ZFS volume snapshot could be fscked
	#
	# STRATEGY:
	# 1. Create a ZFS volume
	# 2. Copy some files and create snapshot
	# 3. Verify fsck on the snapshot is OK
	#

	verify_runnable "global"

	volsize=$(zfs get -H -o value volsize $TESTPOOL/$TESTVOL)

	function cleanup
	{
	snapexists $TESTPOOL/$TESTVOL@snap && \
	- zfs destroy $TESTPOOL/$TESTVOL@snap
	+ destroy_dataset $TESTPOOL/$TESTVOL@snap

	ismounted $TESTDIR $NEWFS_DEFAULT_FS
	(( $? == 0 )) && log_must umount $TESTDIR

	zfs set volsize=$volsize $TESTPOOL/$TESTVOL
	}

	log_assert "Verify that ZFS volume snapshot could be fscked"
	log_onexit cleanup

	TESTVOL='testvol'
	BLOCKSZ=$(( 1024 * 1024 ))
	NUM_WRITES=40

	log_must zfs set volsize=128m $TESTPOOL/$TESTVOL

	log_must new_fs ${ZVOL_RDEVDIR}/$TESTPOOL/$TESTVOL

	log_must mount ${ZVOL_DEVDIR}/$TESTPOOL/$TESTVOL $TESTDIR

	typeset -i fn=0
	typeset -i retval=0

	while (( 1 )); do
	file_write -o create -f $TESTDIR/testfile$$.$fn \
	-b $BLOCKSZ -c $NUM_WRITES
	retval=$?
	if (( $retval != 0 )); then
	break
	fi
	(( fn = fn + 1 ))
	done

	if is_linux \|\| is_freebsd ; then
	log_must sync
	else
	log_must lockfs -f $TESTDIR
	fi

	log_must zfs set snapdev=visible $TESTPOOL/$TESTVOL
	log_must zfs snapshot $TESTPOOL/$TESTVOL@snap
	block_device_wait

	fsck -n ${ZVOL_RDEVDIR}/$TESTPOOL/$TESTVOL@snap >/dev/null 2>&1
	retval=$?

	if [ $retval -ne 0 ] ; then
	if is_linux ; then
	# Linux's fsck returns a different code for this test depending
	# on the version:
	#
	# e2fsprogs-1.43.3 (Fedora 25 and older): returns 4
	# e2fsprogs-1.43.4 (Fedora 26): returns 8
	#
	if [ $retval -ne 4 -a $retval -ne 8 ] ; then
	log_fail "fsck exited with wrong value $retval"
	fi
	else
	if [ $retval -ne 39 ] ; then
	log_fail "fsck exited with wrong value $retval"
	fi
	fi
	fi

	log_pass "Verify that ZFS volume snapshot could be fscked"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/zvol/zvol_misc/zvol_misc_004_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/zvol/zvol_misc/zvol_misc_004_pos.ksh
	index 697887368377..e0dce0c2c34a 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/zvol/zvol_misc/zvol_misc_004_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/zvol/zvol_misc/zvol_misc_004_pos.ksh
	@@ -1,117 +1,116 @@
	#!/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.
	# Copyright 2016 Nexenta Systems, Inc.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/zvol/zvol_common.shlib

	#
	# DESCRIPTION:
	# Verify the ability to take snapshots of zvols used as dump or swap.
	#
	# STRATEGY:
	# 1. Create a ZFS volume
	# 2. Set the volume as dump or swap
	# 3. Verify creating a snapshot of the zvol succeeds.
	#

	verify_runnable "global"

	if ! is_physical_device $DISKS; then
	log_unsupported "This directory cannot be run on raw files."
	fi

	volsize=$(zfs get -H -o value volsize $TESTPOOL/$TESTVOL)

	function cleanup
	{
	typeset dumpdev=$(get_dumpdevice)
	if [[ $dumpdev != $savedumpdev ]] ; then
	safe_dumpadm $savedumpdev
	fi

	swap -l \| grep -w $voldev > /dev/null 2>&1
	if (( $? == 0 )); then
	log_must swap -d $voldev
	fi

	typeset snap
	for snap in snap0 snap1 ; do
	- if datasetexists $TESTPOOL/$TESTVOL@$snap ; then
	- log_must zfs destroy $TESTPOOL/$TESTVOL@$snap
	- fi
	+ datasetexists $TESTPOOL/$TESTVOL@$snap && \
	+ destroy_dataset $TESTPOOL/$TESTVOL@$snap
	done
	zfs set volsize=$volsize $TESTPOOL/$TESTVOL
	}

	function verify_snapshot
	{
	typeset volume=$1

	log_must zfs snapshot $volume@snap0
	log_must zfs snapshot $volume@snap1
	log_must datasetexists $volume@snap0 $volume@snap1

	log_must zfs destroy $volume@snap1
	log_must zfs snapshot $volume@snap1

	log_mustnot zfs rollback -r $volume@snap0
	log_must datasetexists $volume@snap0

	log_must zfs destroy -r $volume@snap0
	}

	log_assert "Verify the ability to take snapshots of zvols used as dump or swap."
	log_onexit cleanup

	voldev=${ZVOL_DEVDIR}/$TESTPOOL/$TESTVOL
	savedumpdev=$(get_dumpdevice)

	# create snapshot over dump zvol
	safe_dumpadm $voldev
	log_must is_zvol_dumpified $TESTPOOL/$TESTVOL

	verify_snapshot $TESTPOOL/$TESTVOL

	safe_dumpadm $savedumpdev
	log_mustnot is_zvol_dumpified $TESTPOOL/$TESTVOL

	# create snapshot over swap zvol

	log_must swap -a $voldev
	log_mustnot is_zvol_dumpified $TESTPOOL/$TESTVOL

	verify_snapshot $TESTPOOL/$TESTVOL

	log_must swap -d $voldev
	log_mustnot is_zvol_dumpified $TESTPOOL/$TESTVOL

	log_pass "Creating snapshots from dump/swap zvols succeeds."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/zvol/zvol_misc/zvol_misc_snapdev.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/zvol/zvol_misc/zvol_misc_snapdev.ksh
	index 8d95bfa39374..1fd87aefdffc 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/zvol/zvol_misc/zvol_misc_snapdev.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/zvol/zvol_misc/zvol_misc_snapdev.ksh
	@@ -1,121 +1,121 @@
	#!/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 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
	. $STF_SUITE/tests/functional/zvol/zvol_common.shlib
	. $STF_SUITE/tests/functional/zvol/zvol_misc/zvol_misc_common.kshlib

	#
	# DESCRIPTION:
	# Verify that ZFS volume property "snapdev" works as intended.
	#
	# STRATEGY:
	# 1. Verify "snapdev" property does not accept invalid values
	# 2. Verify "snapdev" adds and removes device nodes when updated
	# 3. Verify "snapdev" is inherited correctly
	#

	verify_runnable "global"

	function cleanup
	{
	- datasetexists $VOLFS && log_must zfs destroy -r $VOLFS
	- datasetexists $ZVOL && log_must zfs destroy -r $ZVOL
	+ datasetexists $VOLFS && destroy_dataset $VOLFS -r
	+ datasetexists $ZVOL && destroy_dataset $ZVOL -r
	log_must zfs inherit snapdev $TESTPOOL
	block_device_wait
	udev_cleanup
	}

	log_assert "Verify that ZFS volume property 'snapdev' works as expected."
	log_onexit cleanup

	VOLFS="$TESTPOOL/volfs"
	ZVOL="$TESTPOOL/vol"
	SNAP="$ZVOL@snap"
	SNAPDEV="${ZVOL_DEVDIR}/$SNAP"
	SUBZVOL="$VOLFS/subvol"
	SUBSNAP="$SUBZVOL@snap"
	SUBSNAPDEV="${ZVOL_DEVDIR}/$SUBSNAP"

	log_must zfs create -o mountpoint=none $VOLFS
	log_must zfs create -V $VOLSIZE -s $ZVOL
	log_must zfs create -V $VOLSIZE -s $SUBZVOL

	# 1. Verify "snapdev" property does not accept invalid values
	typeset badvals=("off" "on" "1" "nope" "-")
	for badval in ${badvals[@]}
	do
	log_mustnot zfs set snapdev="$badval" $ZVOL
	done

	# 2. Verify "snapdev" adds and removes device nodes when updated
	# 2.1 First create a snapshot then change snapdev property
	log_must zfs snapshot $SNAP
	log_must zfs set snapdev=visible $ZVOL
	blockdev_exists $SNAPDEV
	log_must zfs set snapdev=hidden $ZVOL
	blockdev_missing $SNAPDEV
	log_must zfs destroy $SNAP
	# 2.2 First set snapdev property then create a snapshot
	log_must zfs set snapdev=visible $ZVOL
	log_must zfs snapshot $SNAP
	blockdev_exists $SNAPDEV
	log_must zfs destroy $SNAP
	blockdev_missing $SNAPDEV
	# 2.3 Verify setting to the same value multiple times does not lead to issues
	log_must zfs snapshot $SNAP
	log_must zfs set snapdev=visible $ZVOL
	blockdev_exists $SNAPDEV
	log_must zfs set snapdev=visible $ZVOL
	blockdev_exists $SNAPDEV
	log_must zfs set snapdev=hidden $ZVOL
	blockdev_missing $SNAPDEV
	log_must zfs set snapdev=hidden $ZVOL
	blockdev_missing $SNAPDEV
	log_must zfs destroy $SNAP

	# 3. Verify "snapdev" is inherited correctly
	# 3.1 Check snapdev=visible case
	log_must zfs snapshot $SNAP
	log_must zfs inherit snapdev $ZVOL
	log_must zfs set snapdev=visible $TESTPOOL
	verify_inherited 'snapdev' 'visible' $ZVOL $TESTPOOL
	blockdev_exists $SNAPDEV
	# 3.2 Check snapdev=hidden case
	log_must zfs set snapdev=hidden $TESTPOOL
	verify_inherited 'snapdev' 'hidden' $ZVOL $TESTPOOL
	blockdev_missing $SNAPDEV
	# 3.3 Check inheritance on multiple levels
	log_must zfs snapshot $SUBSNAP
	log_must zfs inherit snapdev $SUBZVOL
	log_must zfs set snapdev=hidden $VOLFS
	log_must zfs set snapdev=visible $TESTPOOL
	verify_inherited 'snapdev' 'hidden' $SUBZVOL $VOLFS
	blockdev_missing $SUBSNAPDEV
	blockdev_exists $SNAPDEV

	log_pass "ZFS volume property 'snapdev' works as expected"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/zvol/zvol_swap/zvol_swap_004_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/zvol/zvol_swap/zvol_swap_004_pos.ksh
	index cf1e6359bdb6..83bf465b633a 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/zvol/zvol_swap/zvol_swap_004_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/zvol/zvol_swap/zvol_swap_004_pos.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) 2013, 2016 by Delphix. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/zvol/zvol_common.shlib

	#
	# DESCRIPTION:
	# When a swap zvol is added its volsize does not change.
	#
	# STRATEGY:
	# 1. Determine what 1/4 arc_c_max is.
	# 2. Create a zvols in a variety of sizes.
	# 3. Add them as swap, and verify the volsize is not changed.
	#

	verify_runnable "global"

	function cleanup
	{
	is_swap_inuse $swapname && log_must swap_cleanup $swapname
	- datasetexists $vol && log_must zfs destroy $vol
	+ datasetexists $vol && destroy_dataset $vol
	}

	log_assert "For an added swap zvol, (2G <= volsize <= 16G)"

	log_onexit cleanup

	for vbs in 8192 16384 32768 65536 131072; do
	for multiplier in 32 16384 131072; do
	((volsize = vbs * multiplier))
	vol="$TESTPOOL/vol_$volsize"
	swapname="${ZVOL_DEVDIR}/$vol"

	# Create a sparse volume to test larger sizes
	log_must zfs create -s -b $vbs -V $volsize $vol
	block_device_wait $swapname
	log_must swap_setup $swapname

	new_volsize=$(get_prop volsize $vol)
	[[ $volsize -eq $new_volsize ]] \|\| log_fail "$volsize $new_volsize"

	log_must swap_cleanup $swapname
	log_must_busy zfs destroy $vol
	done
	done

	log_pass "For an added swap zvol, (2G <= volsize <= 16G)"
	diff --git a/sys/modules/zfs/zfs_config.h b/sys/modules/zfs/zfs_config.h
	index fa3d4feec5de..2e5f26c8ce45 100644
	--- a/sys/modules/zfs/zfs_config.h
	+++ b/sys/modules/zfs/zfs_config.h
	@@ -1,852 +1,870 @@
	/*
	* $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 */

	+/* block_device_operations->submit_bio() returns void */
	+/* #undef HAVE_BDEV_SUBMIT_BIO_RETURNS_VOID */
	+
	/* bdev_whole() is available */
	/* #undef HAVE_BDEV_WHOLE */

	/* bio->bi_bdev->bd_disk exists */
	/* #undef HAVE_BIO_BDEV_DISK */

	/* 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_max_segs() is implemented */
	/* #undef HAVE_BIO_MAX_SEGS */

	/* bio_set_dev() is available */
	/* #undef HAVE_BIO_SET_DEV */

	/* bio_set_dev() GPL-only */
	/* #undef HAVE_BIO_SET_DEV_GPL_ONLY */

	+/* bio_set_dev() is a macro */
	+/* #undef HAVE_BIO_SET_DEV_MACRO */
	+
	/* bio_set_op_attrs is available */
	/* #undef HAVE_BIO_SET_OP_ATTRS */

	+/* blkdev_get_by_path() handles ERESTARTSYS */
	+/* #undef HAVE_BLKDEV_GET_ERESTARTSYS */
	+
	/* 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_disk() exists */
	/* #undef HAVE_BLK_ALLOC_DISK */

	/* 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_update_readahead() exists */
	/* #undef HAVE_BLK_QUEUE_UPDATE_READAHEAD */

	/* 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 if revalidate_disk() in block_device_operations */
	/* #undef HAVE_BLOCK_DEVICE_OPERATIONS_REVALIDATE_DISK */

	/* 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 */

	/* disk__io_acct() available /
	/* #undef HAVE_DISK_IO_ACCT */

	/* disk_update_readahead() exists */
	/* #undef HAVE_DISK_UPDATE_READAHEAD */

	/* 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_fillattr requires struct user_namespace* */
	/* #undef HAVE_GENERIC_FILLATTR_USERNS */

	/* 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_acl() exists */
	/* #undef HAVE_GET_ACL */

	/* iops->get_acl() takes rcu */
	/* #undef HAVE_GET_ACL_RCU */

	/* 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_owner_or_capable() exists */
	/* #undef HAVE_INODE_OWNER_OR_CAPABLE */

	/* inode_owner_or_capable() takes user_ns */
	/* #undef HAVE_INODE_OWNER_OR_CAPABLE_IDMAPPED */

	/* 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 */

	/* iops->create() takes struct user_namespace* */
	/* #undef HAVE_IOPS_CREATE_USERNS */

	/* iops->mkdir() takes struct user_namespace* */
	/* #undef HAVE_IOPS_MKDIR_USERNS */

	/* iops->mknod() takes struct user_namespace* */
	/* #undef HAVE_IOPS_MKNOD_USERNS */

	/* iops->rename() takes struct user_namespace* */
	/* #undef HAVE_IOPS_RENAME_USERNS */

	/* iops->symlink() takes struct user_namespace* */
	/* #undef HAVE_IOPS_SYMLINK_USERNS */

	/* 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_revert() is available */
	/* #undef HAVE_IOV_ITER_REVERT */

	+/* iov_iter_type() is available */
	+/* #undef HAVE_IOV_ITER_TYPE */
	+
	/* 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 */

	+/* kernel has asm/fpu/xcr.h */
	+/* #undef HAVE_KERNEL_FPU_XCR_HEADER */
	+
	/* 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 */

	+/* linux/blk-cgroup.h exists */
	+/* #undef HAVE_LINUX_BLK_CGROUP_HEADER */
	+
	/* 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->mkdir() takes 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 */

	+/* folio_wait_bit() exists */
	+/* #undef HAVE_PAGEMAP_FOLIO_WAIT_BIT */
	+
	/* iops->getattr() takes a path */
	/* #undef HAVE_PATH_IOPS_GETATTR */

	/* Define if host toolchain supports PCLMULQDQ */
	#define HAVE_PCLMULQDQ 1

	/* percpu_counter_add_batch() is defined */
	/* #undef HAVE_PERCPU_COUNTER_ADD_BATCH */

	/* 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, doesn't accept user_namespace */
	/* #undef HAVE_SETATTR_PREPARE_NO_USERNS */

	/* setattr_prepare() accepts user_namespace */
	/* #undef HAVE_SETATTR_PREPARE_USERNS */

	/* iops->set_acl() exists, takes 3 args */
	/* #undef HAVE_SET_ACL */

	/* iops->set_acl() takes 4 args */
	/* #undef HAVE_SET_ACL_USERNS */

	/* set_cached_acl() is usable */
	/* #undef HAVE_SET_CACHED_ACL_USABLE */

	/* set_special_state() exists */
	/* #undef HAVE_SET_SPECIAL_STATE */

	/* struct shrink_control exists */
	/* #undef HAVE_SHRINK_CONTROL_STRUCT */

	/* kernel_siginfo_t exists */
	/* #undef HAVE_SIGINFO */

	/* signal_stop() exists */
	/* #undef HAVE_SIGNAL_STOP */

	/* 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 */

	/* standalone <linux/stdarg.h> exists */
	/* #undef HAVE_STANDALONE_LINUX_STDARG */

	/* 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 */

	/* i_op->tmpfile() has userns */
	/* #undef HAVE_TMPFILE_USERNS */

	/* 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 struct user_namespace* */
	/* #undef HAVE_USERNS_IOPS_GETATTR */

	/* 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 */

	/* __set_page_dirty_nobuffers exists */
	/* #undef HAVE_VFS_SET_PAGE_DIRTY_NOBUFFERS */

	/* __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 */

	/* xattr_handler->set() takes user_namespace */
	/* #undef HAVE_XATTR_SET_USERNS */

	/* 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.1-FreeBSD_g71c609852"
	+#define ZFS_META_ALIAS "zfs-2.1.2-FreeBSD_gaf88d47f1"

	/* 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.14"
	+#define ZFS_META_KVER_MAX "5.15"

	/* 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_g71c609852"
	+#define ZFS_META_RELEASE "FreeBSD_gaf88d47f1"

	/* Define the project version. */
	-#define ZFS_META_VERSION "2.1.1"
	+#define ZFS_META_VERSION "2.1.2"

	/* count is located in percpu_ref.data */
	/* #undef ZFS_PERCPU_REF_COUNT_IN_DATA */

	diff --git a/sys/modules/zfs/zfs_gitrev.h b/sys/modules/zfs/zfs_gitrev.h
	index cbaa4c41658b..bafe6026a6a8 100644
	--- a/sys/modules/zfs/zfs_gitrev.h
	+++ b/sys/modules/zfs/zfs_gitrev.h
	@@ -1,5 +1,5 @@
	/*
	* $FreeBSD$
	*/

	-#define ZFS_META_GITREV "zfs-2.1.1-0-g71c609852"
	+#define ZFS_META_GITREV "zfs-2.1.2-0-gaf88d47f1"

File Metadata

Mime Type: application/octet-stream
Expires: Sun, May 5, 12:11 PM (2 d)
Storage Engine: chunks
Storage Format: Chunks
Storage Handle: T578kSzLT2RK
Default Alt Text: (7 MB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions